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