src/jalview/datamodel/xdb/embl/EmblEntry.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.datamodel.xdb.embl;
  22
  23 import jalview.analysis.SequenceIdMatcher;
  24 import jalview.bin.Cache;
  25 import jalview.datamodel.DBRefEntry;
  26 import jalview.datamodel.DBRefSource;
  27 import jalview.datamodel.FeatureProperties;
  28 import jalview.datamodel.Mapping;
  29 import jalview.datamodel.Sequence;
  30 import jalview.datamodel.SequenceFeature;
  31 import jalview.datamodel.SequenceI;
  32 import jalview.util.DBRefUtils;
  33 import jalview.util.DnaUtils;
  34 import jalview.util.MapList;
  35 import jalview.util.MappingUtils;
  36 import jalview.util.StringUtils;
  37
  38 import java.text.ParseException;
  39 import java.util.Arrays;
  40 import java.util.Hashtable;
  41 import java.util.List;
  42 import java.util.Map;
  43 import java.util.Map.Entry;
  44 import java.util.Vector;
  45 import java.util.regex.Pattern;
  46
  47 /**
  48  * Data model for one entry returned from an EMBL query, as marshalled by a
  49  * Castor binding file
  50  *
  51  * For example:
  52  * http://www.ebi.ac.uk/ena/data/view/J03321&display=xml
  53  *
  54  * @see embl_mapping.xml
  55  */
  56 public class EmblEntry
  57 {
  58   private static final Pattern SPACE_PATTERN = Pattern.compile(" ");
  59
  60   String accession;
  61
  62   String entryVersion;
  63
  64   String sequenceVersion;
  65
  66   String dataClass;
  67
  68   String moleculeType;
  69
  70   String topology;
  71
  72   String sequenceLength;
  73
  74   String taxonomicDivision;
  75
  76   String description;
  77
  78   String firstPublicDate;
  79
  80   String firstPublicRelease;
  81
  82   String lastUpdatedDate;
  83
  84   String lastUpdatedRelease;
  85
  86   Vector<String> keywords;
  87
  88   Vector<DBRefEntry> dbRefs;
  89
  90   Vector<EmblFeature> features;
  91
  92   EmblSequence sequence;
  93
  94   /**
  95    * @return the accession
  96    */
  97   public String getAccession()
  98   {
  99     return accession;
 100   }
 101
 102   /**
 103    * @param accession
 104    *          the accession to set
 105    */
 106   public void setAccession(String accession)
 107   {
 108     this.accession = accession;
 109   }
 110
 111   /**
 112    * @return the dbRefs
 113    */
 114   public Vector<DBRefEntry> getDbRefs()
 115   {
 116     return dbRefs;
 117   }
 118
 119   /**
 120    * @param dbRefs
 121    *          the dbRefs to set
 122    */
 123   public void setDbRefs(Vector<DBRefEntry> dbRefs)
 124   {
 125     this.dbRefs = dbRefs;
 126   }
 127
 128   /**
 129    * @return the features
 130    */
 131   public Vector<EmblFeature> getFeatures()
 132   {
 133     return features;
 134   }
 135
 136   /**
 137    * @param features
 138    *          the features to set
 139    */
 140   public void setFeatures(Vector<EmblFeature> features)
 141   {
 142     this.features = features;
 143   }
 144
 145   /**
 146    * @return the keywords
 147    */
 148   public Vector<String> getKeywords()
 149   {
 150     return keywords;
 151   }
 152
 153   /**
 154    * @param keywords
 155    *          the keywords to set
 156    */
 157   public void setKeywords(Vector<String> keywords)
 158   {
 159     this.keywords = keywords;
 160   }
 161
 162   /**
 163    * @return the sequence
 164    */
 165   public EmblSequence getSequence()
 166   {
 167     return sequence;
 168   }
 169
 170   /**
 171    * @param sequence
 172    *          the sequence to set
 173    */
 174   public void setSequence(EmblSequence sequence)
 175   {
 176     this.sequence = sequence;
 177   }
 178
 179   /**
 180    * Recover annotated sequences from EMBL file
 181    *
 182    * @param sourceDb
 183    * @param peptides
 184    *          a list of protein products found so far (to add to)
 185    * @return dna dataset sequence with DBRefs and features
 186    */
 187   public SequenceI getSequence(String sourceDb, List<SequenceI> peptides)
 188   {
 189     SequenceI dna = makeSequence(sourceDb);
 190     if (dna == null)
 191     {
 192       return null;
 193     }
 194     dna.setDescription(description);
 195     DBRefEntry retrievedref = new DBRefEntry(sourceDb,
 196             getSequenceVersion(), accession);
 197     dna.addDBRef(retrievedref);
 198     // add map to indicate the sequence is a valid coordinate frame for the
 199     // dbref
 200     retrievedref.setMap(new Mapping(null, new int[] { 1, dna.getLength() },
 201             new int[] { 1, dna.getLength() }, 1, 1));
 202
 203
 204     /*
 205      * transform EMBL Database refs to canonical form
 206      */
 207     if (dbRefs != null)
 208     {
 209       for (DBRefEntry dbref : dbRefs)
 210       {
 211         dbref.setSource(DBRefUtils.getCanonicalName(dbref.getSource()));
 212         dna.addDBRef(dbref);
 213       }
 214     }
 215
 216     SequenceIdMatcher matcher = new SequenceIdMatcher(peptides);
 217     try
 218     {
 219       for (EmblFeature feature : features)
 220       {
 221         if (FeatureProperties.isCodingFeature(sourceDb, feature.getName()))
 222         {
 223           parseCodingFeature(feature, sourceDb, dna, peptides, matcher);
 224         }
 225       }
 226     } catch (Exception e)
 227     {
 228       System.err.println("EMBL Record Features parsing error!");
 229       System.err
 230               .println("Please report the following to help@jalview.org :");
 231       System.err.println("EMBL Record " + accession);
 232       System.err.println("Resulted in exception: " + e.getMessage());
 233       e.printStackTrace(System.err);
 234     }
 235
 236     return dna;
 237   }
 238
 239   /**
 240    * @param sourceDb
 241    * @return
 242    */
 243   SequenceI makeSequence(String sourceDb)
 244   {
 245     if (sequence == null)
 246     {
 247       System.err.println("No sequence was returned for ENA accession "
 248               + accession);
 249       return null;
 250     }
 251     SequenceI dna = new Sequence(sourceDb + "|" + accession,
 252             sequence.getSequence());
 253     return dna;
 254   }
 255
 256   /**
 257    * Extracts coding region and product from a CDS feature and properly decorate
 258    * it with annotations.
 259    *
 260    * @param feature
 261    *          coding feature
 262    * @param sourceDb
 263    *          source database for the EMBLXML
 264    * @param dna
 265    *          parent dna sequence for this record
 266    * @param peptides
 267    *          list of protein product sequences for Embl entry
 268    * @param matcher
 269    *          helper to match xrefs in already retrieved sequences
 270    */
 271   void parseCodingFeature(EmblFeature feature, String sourceDb,
 272           SequenceI dna, List<SequenceI> peptides, SequenceIdMatcher matcher)
 273   {
 274     boolean isEmblCdna = sourceDb.equals(DBRefSource.EMBLCDS);
 275
 276     int[] exons = getCdsRanges(feature);
 277
 278     String translation = null;
 279     String proteinName = "";
 280     String proteinId = null;
 281     Map<String, String> vals = new Hashtable<String, String>();
 282
 283     /*
 284      * codon_start 1/2/3 in EMBL corresponds to phase 0/1/2 in CDS
 285      * (phase is required for CDS features in GFF3 format)
 286      */
 287     int codonStart = 1;
 288
 289     /*
 290      * parse qualifiers, saving protein translation, protein id,
 291      * codon start position, product (name), and 'other values'
 292      */
 293     if (feature.getQualifiers() != null)
 294     {
 295       for (Qualifier q : feature.getQualifiers())
 296       {
 297         String qname = q.getName();
 298         if (qname.equals("translation"))
 299         {
 300           // remove all spaces (precompiled String.replaceAll(" ", ""))
 301           translation = SPACE_PATTERN.matcher(q.getValues()[0]).replaceAll("");
 302         }
 303         else if (qname.equals("protein_id"))
 304         {
 305           proteinId = q.getValues()[0].trim();
 306         }
 307         else if (qname.equals("codon_start"))
 308         {
 309           try
 310           {
 311             codonStart = Integer.parseInt(q.getValues()[0].trim());
 312           } catch (NumberFormatException e)
 313           {
 314             System.err.println("Invalid codon_start in XML for "
 315                     + accession + ": " + e.getMessage());
 316           }
 317         }
 318         else if (qname.equals("product"))
 319         {
 320           // sometimes name is returned e.g. for V00488
 321           proteinName = q.getValues()[0].trim();
 322         }
 323         else
 324         {
 325           // throw anything else into the additional properties hash
 326           String[] qvals = q.getValues();
 327           if (qvals != null)
 328           {
 329             String commaSeparated = StringUtils.arrayToSeparatorList(qvals,
 330                     ",");
 331             vals.put(qname, commaSeparated);
 332           }
 333         }
 334       }
 335     }
 336
 337     DBRefEntry proteinToEmblProteinRef = null;
 338     exons = MappingUtils.removeStartPositions(codonStart - 1, exons);
 339
 340     SequenceI product = null;
 341     Mapping dnaToProteinMapping = null;
 342     if (translation != null && proteinName != null && proteinId != null)
 343     {
 344       int translationLength = translation.length();
 345
 346       /*
 347        * look for product in peptides list, if not found, add it
 348        */
 349       product = matcher.findIdMatch(proteinId);
 350       if (product == null)
 351       {
 352         product = new Sequence(proteinId, translation, 1, translationLength);
 353         product.setDescription(((proteinName.length() == 0) ? "Protein Product from "
 354                 + sourceDb
 355                 : proteinName));
 356         peptides.add(product);
 357         matcher.add(product);
 358       }
 359
 360       // we have everything - create the mapping and perhaps the protein
 361       // sequence
 362       if (exons == null || exons.length == 0)
 363       {
 364         /*
 365          * workaround until we handle dna location for CDS sequence
 366          * e.g. location="X53828.1:60..1058" correctly
 367          */
 368         System.err
 369                 .println("Implementation Notice: EMBLCDS records not properly supported yet - Making up the CDNA region of this sequence... may be incorrect ("
 370                         + sourceDb + ":" + getAccession() + ")");
 371         if (translationLength * 3 == (1 - codonStart + dna.getSequence().length))
 372         {
 373           System.err
 374                   .println("Not allowing for additional stop codon at end of cDNA fragment... !");
 375           // this might occur for CDS sequences where no features are marked
 376           exons = new int[] { dna.getStart() + (codonStart - 1),
 377               dna.getEnd() };
 378           dnaToProteinMapping = new Mapping(product, exons, new int[] { 1,
 379               translationLength }, 3, 1);
 380         }
 381         if ((translationLength + 1) * 3 == (1 - codonStart + dna
 382                 .getSequence().length))
 383         {
 384           System.err
 385                   .println("Allowing for additional stop codon at end of cDNA fragment... will probably cause an error in VAMSAs!");
 386           exons = new int[] { dna.getStart() + (codonStart - 1),
 387               dna.getEnd() - 3 };
 388           dnaToProteinMapping = new Mapping(product, exons, new int[] { 1,
 389               translationLength }, 3, 1);
 390         }
 391       }
 392       else
 393       {
 394         // Trim the exon mapping if necessary - the given product may only be a
 395         // fragment of a larger protein. (EMBL:AY043181 is an example)
 396
 397         if (isEmblCdna)
 398         {
 399           // TODO: Add a DbRef back to the parent EMBL sequence with the exon
 400           // map
 401           // if given a dataset reference, search dataset for parent EMBL
 402           // sequence if it exists and set its map
 403           // make a new feature annotating the coding contig
 404         }
 405         else
 406         {
 407           // final product length truncation check
 408           int[] cdsRanges = adjustForProteinLength(translationLength, exons);
 409           dnaToProteinMapping = new Mapping(product, cdsRanges, new int[] {
 410               1, translationLength }, 3, 1);
 411           if (product != null)
 412           {
 413             /*
 414              * make xref with mapping from protein to EMBL dna
 415              */
 416             DBRefEntry proteinToEmblRef = new DBRefEntry(DBRefSource.EMBL,
 417                     getSequenceVersion(), proteinId, new Mapping(
 418                             dnaToProteinMapping.getMap().getInverse()));
 419             product.addDBRef(proteinToEmblRef);
 420
 421             /*
 422              * make xref from protein to EMBLCDS; we assume here that the
 423              * CDS sequence version is same as dna sequence (?!)
 424              */
 425             MapList proteinToCdsMapList = new MapList(new int[] { 1,
 426                 translationLength }, new int[] { 1 + (codonStart - 1),
 427                 (codonStart - 1) + 3 * translationLength }, 1, 3);
 428             DBRefEntry proteinToEmblCdsRef = new DBRefEntry(
 429                     DBRefSource.EMBLCDS, getSequenceVersion(), proteinId,
 430                     new Mapping(proteinToCdsMapList));
 431             product.addDBRef(proteinToEmblCdsRef);
 432
 433             /*
 434              * make 'direct' xref from protein to EMBLCDSPROTEIN
 435              */
 436             proteinToEmblProteinRef = new DBRefEntry(proteinToEmblCdsRef);
 437             proteinToEmblProteinRef.setSource(DBRefSource.EMBLCDSProduct);
 438             proteinToEmblProteinRef.setMap(null);
 439             product.addDBRef(proteinToEmblProteinRef);
 440           }
 441         }
 442       }
 443
 444       /*
 445        * add cds features to dna sequence
 446        */
 447       for (int xint = 0; exons != null && xint < exons.length; xint += 2)
 448       {
 449         SequenceFeature sf = makeCdsFeature(exons, xint, proteinName,
 450                 proteinId, vals, codonStart);
 451         sf.setType(feature.getName()); // "CDS"
 452         sf.setEnaLocation(feature.getLocation());
 453         sf.setFeatureGroup(sourceDb);
 454         dna.addSequenceFeature(sf);
 455       }
 456     }
 457
 458     /*
 459      * add feature dbRefs to sequence, and mappings for Uniprot xrefs
 460      */
 461     boolean hasUniprotDbref = false;
 462     if (feature.dbRefs != null)
 463     {
 464       boolean mappingUsed = false;
 465       for (DBRefEntry ref : feature.dbRefs)
 466       {
 467         /*
 468          * ensure UniProtKB/Swiss-Prot converted to UNIPROT
 469          */
 470         String source = DBRefUtils.getCanonicalName(ref.getSource());
 471         ref.setSource(source);
 472         DBRefEntry proteinDbRef = new DBRefEntry(ref.getSource(), ref.getVersion(), ref
 473                 .getAccessionId());
 474         if (source.equals(DBRefSource.UNIPROT))
 475         {
 476           String proteinSeqName = DBRefSource.UNIPROT + "|"
 477                   + ref.getAccessionId();
 478           if (dnaToProteinMapping != null && dnaToProteinMapping.getTo() != null)
 479           {
 480             if (mappingUsed)
 481             {
 482               /*
 483                * two or more Uniprot xrefs for the same CDS -
 484                * each needs a distinct Mapping (as to a different sequence)
 485                */
 486               dnaToProteinMapping = new Mapping(dnaToProteinMapping);
 487             }
 488             mappingUsed = true;
 489
 490             /*
 491              * try to locate the protein mapped to (possibly by a
 492              * previous CDS feature); if not found, construct it from
 493              * the EMBL translation
 494              */
 495             SequenceI proteinSeq = matcher.findIdMatch(proteinSeqName);
 496             if (proteinSeq == null)
 497             {
 498               proteinSeq = new Sequence(proteinSeqName,
 499                       product.getSequenceAsString());
 500               matcher.add(proteinSeq);
 501               peptides.add(proteinSeq);
 502             }
 503             dnaToProteinMapping.setTo(proteinSeq);
 504             dnaToProteinMapping.setMappedFromId(proteinId);
 505             proteinSeq.addDBRef(proteinDbRef);
 506             ref.setMap(dnaToProteinMapping);
 507           }
 508           hasUniprotDbref = true;
 509         }
 510         if (product != null)
 511         {
 512           /*
 513            * copy feature dbref to our protein product
 514            */
 515           DBRefEntry pref = proteinDbRef;
 516           pref.setMap(null); // reference is direct
 517           product.addDBRef(pref);
 518           // Add converse mapping reference
 519           if (dnaToProteinMapping != null)
 520           {
 521             Mapping pmap = new Mapping(dna, dnaToProteinMapping.getMap()
 522                     .getInverse());
 523             pref = new DBRefEntry(sourceDb, getSequenceVersion(),
 524                     this.getAccession());
 525             pref.setMap(pmap);
 526             if (dnaToProteinMapping.getTo() != null)
 527             {
 528               dnaToProteinMapping.getTo().addDBRef(pref);
 529             }
 530           }
 531         }
 532         dna.addDBRef(ref);
 533       }
 534     }
 535
 536     /*
 537      * if we have a product (translation) but no explicit Uniprot dbref
 538      * (example: EMBL AAFI02000057 protein_id EAL65544.1)
 539      * then construct mappings to an assumed EMBLCDSPROTEIN accession
 540      */
 541     if (!hasUniprotDbref && product != null)
 542     {
 543       if (proteinToEmblProteinRef == null)
 544       {
 545         // assuming CDSPROTEIN sequence version = dna version (?!)
 546         proteinToEmblProteinRef = new DBRefEntry(
 547                 DBRefSource.EMBLCDSProduct, getSequenceVersion(), proteinId);
 548       }
 549       product.addDBRef(proteinToEmblProteinRef);
 550
 551       if (dnaToProteinMapping != null
 552               && dnaToProteinMapping.getTo() != null)
 553       {
 554         DBRefEntry dnaToEmblProteinRef = new DBRefEntry(
 555                 DBRefSource.EMBLCDSProduct, getSequenceVersion(), proteinId);
 556         dnaToEmblProteinRef.setMap(dnaToProteinMapping);
 557         dnaToProteinMapping.setMappedFromId(proteinId);
 558         dna.addDBRef(dnaToEmblProteinRef);
 559       }
 560     }
 561   }
 562
 563   /**
 564    * Helper method to construct a SequenceFeature for one cds range
 565    *
 566    * @param exons
 567    *          array of cds [start, end, ...] positions
 568    * @param exonStartIndex
 569    *          offset into the exons array
 570    * @param proteinName
 571    * @param proteinAccessionId
 572    * @param vals
 573    *          map of 'miscellaneous values' for feature
 574    * @param codonStart
 575    *          codon start position for CDS (1/2/3, normally 1)
 576    * @return
 577    */
 578   protected SequenceFeature makeCdsFeature(int[] exons, int exonStartIndex,
 579           String proteinName, String proteinAccessionId,
 580           Map<String, String> vals, int codonStart)
 581   {
 582     int exonNumber = exonStartIndex / 2 + 1;
 583     SequenceFeature sf = new SequenceFeature();
 584     sf.setBegin(Math.min(exons[exonStartIndex], exons[exonStartIndex + 1]));
 585     sf.setEnd(Math.max(exons[exonStartIndex], exons[exonStartIndex + 1]));
 586     sf.setDescription(String.format("Exon %d for protein '%s' EMBLCDS:%s",
 587             exonNumber, proteinName, proteinAccessionId));
 588     sf.setPhase(String.valueOf(codonStart - 1));
 589     sf.setStrand(exons[exonStartIndex] <= exons[exonStartIndex + 1] ? "+"
 590             : "-");
 591     sf.setValue(FeatureProperties.EXONPOS, exonNumber);
 592     sf.setValue(FeatureProperties.EXONPRODUCT, proteinName);
 593     if (!vals.isEmpty())
 594     {
 595       StringBuilder sb = new StringBuilder();
 596       boolean first = true;
 597       for (Entry<String, String> val : vals.entrySet())
 598       {
 599         if (!first)
 600         {
 601           sb.append(";");
 602         }
 603         sb.append(val.getKey()).append("=").append(val.getValue());
 604         first = false;
 605         sf.setValue(val.getKey(), val.getValue());
 606       }
 607       sf.setAttributes(sb.toString());
 608     }
 609     return sf;
 610   }
 611
 612   /**
 613    * Returns the CDS positions as a single array of [start, end, start, end...]
 614    * positions. If on the reverse strand, these will be in descending order.
 615    *
 616    * @param feature
 617    * @return
 618    */
 619   protected int[] getCdsRanges(EmblFeature feature)
 620   {
 621     if (feature.location == null)
 622     {
 623       return new int[] {};
 624     }
 625
 626     try
 627     {
 628       List<int[]> ranges = DnaUtils.parseLocation(feature.location);
 629       return listToArray(ranges);
 630     } catch (ParseException e)
 631     {
 632       Cache.log.warn(String.format(
 633               "Not parsing inexact CDS location %s in ENA %s",
 634               feature.location, this.accession));
 635       return new int[] {};
 636     }
 637   }
 638
 639   /**
 640    * Converts a list of [start, end] ranges to a single array of [start, end,
 641    * start, end ...]
 642    *
 643    * @param ranges
 644    * @return
 645    */
 646   int[] listToArray(List<int[]> ranges)
 647   {
 648     int[] result = new int[ranges.size() * 2];
 649     int i = 0;
 650     for (int[] range : ranges)
 651     {
 652       result[i++] = range[0];
 653       result[i++] = range[1];
 654     }
 655     return result;
 656   }
 657
 658   /**
 659    * Truncates (if necessary) the exon intervals to match 3 times the length of
 660    * the protein; also accepts 3 bases longer (for stop codon not included in
 661    * protein)
 662    *
 663    * @param proteinLength
 664    * @param exon
 665    *          an array of [start, end, start, end...] intervals
 666    * @return the same array (if unchanged) or a truncated copy
 667    */
 668   static int[] adjustForProteinLength(int proteinLength, int[] exon)
 669   {
 670     if (proteinLength <= 0 || exon == null)
 671     {
 672       return exon;
 673     }
 674     int expectedCdsLength = proteinLength * 3;
 675     int exonLength = MappingUtils.getLength(Arrays.asList(exon));
 676
 677     /*
 678      * if exon length matches protein, or is shorter, or longer by the
 679      * length of a stop codon (3 bases), then leave it unchanged
 680      */
 681     if (expectedCdsLength >= exonLength
 682             || expectedCdsLength == exonLength - 3)
 683     {
 684       return exon;
 685     }
 686
 687     int origxon[];
 688     int sxpos = -1;
 689     int endxon = 0;
 690     origxon = new int[exon.length];
 691     System.arraycopy(exon, 0, origxon, 0, exon.length);
 692     int cdspos = 0;
 693     for (int x = 0; x < exon.length; x += 2)
 694     {
 695       cdspos += Math.abs(exon[x + 1] - exon[x]) + 1;
 696       if (expectedCdsLength <= cdspos)
 697       {
 698         // advanced beyond last codon.
 699         sxpos = x;
 700         if (expectedCdsLength != cdspos)
 701         {
 702           // System.err
 703           // .println("Truncating final exon interval on region by "
 704           // + (cdspos - cdslength));
 705         }
 706
 707         /*
 708          * shrink the final exon - reduce end position if forward
 709          * strand, increase it if reverse
 710          */
 711         if (exon[x + 1] >= exon[x])
 712         {
 713           endxon = exon[x + 1] - cdspos + expectedCdsLength;
 714         }
 715         else
 716         {
 717           endxon = exon[x + 1] + cdspos - expectedCdsLength;
 718         }
 719         break;
 720       }
 721     }
 722
 723     if (sxpos != -1)
 724     {
 725       // and trim the exon interval set if necessary
 726       int[] nxon = new int[sxpos + 2];
 727       System.arraycopy(exon, 0, nxon, 0, sxpos + 2);
 728       nxon[sxpos + 1] = endxon; // update the end boundary for the new exon
 729                                 // set
 730       exon = nxon;
 731     }
 732     return exon;
 733   }
 734
 735   public String getSequenceVersion()
 736   {
 737     return sequenceVersion;
 738   }
 739
 740   public void setSequenceVersion(String sequenceVersion)
 741   {
 742     this.sequenceVersion = sequenceVersion;
 743   }
 744
 745   public String getSequenceLength()
 746   {
 747     return sequenceLength;
 748   }
 749
 750   public void setSequenceLength(String sequenceLength)
 751   {
 752     this.sequenceLength = sequenceLength;
 753   }
 754
 755   public String getEntryVersion()
 756   {
 757     return entryVersion;
 758   }
 759
 760   public void setEntryVersion(String entryVersion)
 761   {
 762     this.entryVersion = entryVersion;
 763   }
 764
 765   public String getMoleculeType()
 766   {
 767     return moleculeType;
 768   }
 769
 770   public void setMoleculeType(String moleculeType)
 771   {
 772     this.moleculeType = moleculeType;
 773   }
 774
 775   public String getTopology()
 776   {
 777     return topology;
 778   }
 779
 780   public void setTopology(String topology)
 781   {
 782     this.topology = topology;
 783   }
 784
 785   public String getTaxonomicDivision()
 786   {
 787     return taxonomicDivision;
 788   }
 789
 790   public void setTaxonomicDivision(String taxonomicDivision)
 791   {
 792     this.taxonomicDivision = taxonomicDivision;
 793   }
 794
 795   public String getDescription()
 796   {
 797     return description;
 798   }
 799
 800   public void setDescription(String description)
 801   {
 802     this.description = description;
 803   }
 804
 805   public String getFirstPublicDate()
 806   {
 807     return firstPublicDate;
 808   }
 809
 810   public void setFirstPublicDate(String firstPublicDate)
 811   {
 812     this.firstPublicDate = firstPublicDate;
 813   }
 814
 815   public String getFirstPublicRelease()
 816   {
 817     return firstPublicRelease;
 818   }
 819
 820   public void setFirstPublicRelease(String firstPublicRelease)
 821   {
 822     this.firstPublicRelease = firstPublicRelease;
 823   }
 824
 825   public String getLastUpdatedDate()
 826   {
 827     return lastUpdatedDate;
 828   }
 829
 830   public void setLastUpdatedDate(String lastUpdatedDate)
 831   {
 832     this.lastUpdatedDate = lastUpdatedDate;
 833   }
 834
 835   public String getLastUpdatedRelease()
 836   {
 837     return lastUpdatedRelease;
 838   }
 839
 840   public void setLastUpdatedRelease(String lastUpdatedRelease)
 841   {
 842     this.lastUpdatedRelease = lastUpdatedRelease;
 843   }
 844
 845   public String getDataClass()
 846   {
 847     return dataClass;
 848   }
 849
 850   public void setDataClass(String dataClass)
 851   {
 852     this.dataClass = dataClass;
 853   }
 854 }