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