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 = new Sequence(sourceDb + "|" + accession,
 191             sequence.getSequence());
 192     dna.setDescription(description);
 193     DBRefEntry retrievedref = new DBRefEntry(sourceDb,
 194             getSequenceVersion(), accession);
 195     dna.addDBRef(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    * Extracts coding region and product from a CDS feature and properly decorate
 239    * it with annotations.
 240    *
 241    * @param feature
 242    *          coding feature
 243    * @param sourceDb
 244    *          source database for the EMBLXML
 245    * @param dna
 246    *          parent dna sequence for this record
 247    * @param peptides
 248    *          list of protein product sequences for Embl entry
 249    * @param matcher
 250    *          helper to match xrefs in already retrieved sequences
 251    */
 252   void parseCodingFeature(EmblFeature feature, String sourceDb,
 253           SequenceI dna, List<SequenceI> peptides, SequenceIdMatcher matcher)
 254   {
 255     boolean isEmblCdna = sourceDb.equals(DBRefSource.EMBLCDS);
 256
 257     int[] exons = getCdsRanges(feature);
 258
 259     String translation = null;
 260     String proteinName = "";
 261     String proteinId = null;
 262     Map<String, String> vals = new Hashtable<String, String>();
 263
 264     /*
 265      * codon_start 1/2/3 in EMBL corresponds to phase 0/1/2 in CDS
 266      * (phase is required for CDS features in GFF3 format)
 267      */
 268     int codonStart = 1;
 269
 270     /*
 271      * parse qualifiers, saving protein translation, protein id,
 272      * codon start position, product (name), and 'other values'
 273      */
 274     if (feature.getQualifiers() != null)
 275     {
 276       for (Qualifier q : feature.getQualifiers())
 277       {
 278         String qname = q.getName();
 279         if (qname.equals("translation"))
 280         {
 281           // remove all spaces (precompiled String.replaceAll(" ", ""))
 282           translation = SPACE_PATTERN.matcher(q.getValues()[0]).replaceAll("");
 283         }
 284         else if (qname.equals("protein_id"))
 285         {
 286           proteinId = q.getValues()[0].trim();
 287         }
 288         else if (qname.equals("codon_start"))
 289         {
 290           try
 291           {
 292             codonStart = Integer.parseInt(q.getValues()[0].trim());
 293           } catch (NumberFormatException e)
 294           {
 295             System.err.println("Invalid codon_start in XML for "
 296                     + accession + ": " + e.getMessage());
 297           }
 298         }
 299         else if (qname.equals("product"))
 300         {
 301           // sometimes name is returned e.g. for V00488
 302           proteinName = q.getValues()[0].trim();
 303         }
 304         else
 305         {
 306           // throw anything else into the additional properties hash
 307           String[] qvals = q.getValues();
 308           if (qvals != null)
 309           {
 310             String commaSeparated = StringUtils.arrayToSeparatorList(qvals,
 311                     ",");
 312             vals.put(qname, commaSeparated);
 313           }
 314         }
 315       }
 316     }
 317
 318     DBRefEntry proteinToEmblProteinRef = null;
 319     exons = MappingUtils.removeStartPositions(codonStart - 1, exons);
 320
 321     SequenceI product = null;
 322     Mapping dnaToProteinMapping = null;
 323     if (translation != null && proteinName != null && proteinId != null)
 324     {
 325       /*
 326        * look for product in peptides list, if not found, add it
 327        */
 328       product = matcher.findIdMatch(proteinId);
 329       if (product == null)
 330       {
 331         product = new Sequence(proteinId, translation, 1, translation.length());
 332         product.setDescription(((proteinName.length() == 0) ? "Protein Product from "
 333                 + sourceDb
 334                 : proteinName));
 335         peptides.add(product);
 336         matcher.add(product);
 337       }
 338
 339       // we have everything - create the mapping and perhaps the protein
 340       // sequence
 341       if (exons == null || exons.length == 0)
 342       {
 343         System.err
 344                 .println("Implementation Notice: EMBLCDS records not properly supported yet - Making up the CDNA region of this sequence... may be incorrect ("
 345                         + sourceDb + ":" + getAccession() + ")");
 346         if (translation.length() * 3 == (1 - codonStart + dna.getSequence().length))
 347         {
 348           System.err
 349                   .println("Not allowing for additional stop codon at end of cDNA fragment... !");
 350           // this might occur for CDS sequences where no features are
 351           // marked.
 352           exons = new int[] { dna.getStart() + (codonStart - 1),
 353               dna.getEnd() };
 354           dnaToProteinMapping = new Mapping(product, exons, new int[] { 1,
 355               translation.length() },
 356                   3, 1);
 357         }
 358         if ((translation.length() + 1) * 3 == (1 - codonStart + dna.getSequence().length))
 359         {
 360           System.err
 361                   .println("Allowing for additional stop codon at end of cDNA fragment... will probably cause an error in VAMSAs!");
 362           exons = new int[] { dna.getStart() + (codonStart - 1),
 363               dna.getEnd() - 3 };
 364           dnaToProteinMapping = new Mapping(product, exons, new int[] { 1,
 365               translation.length() },
 366                   3, 1);
 367         }
 368       }
 369       else
 370       {
 371         // Trim the exon mapping if necessary - the given product may only be a
 372         // fragment of a larger protein. (EMBL:AY043181 is an example)
 373
 374         if (isEmblCdna)
 375         {
 376           // TODO: Add a DbRef back to the parent EMBL sequence with the exon
 377           // map
 378           // if given a dataset reference, search dataset for parent EMBL
 379           // sequence if it exists and set its map
 380           // make a new feature annotating the coding contig
 381         }
 382         else
 383         {
 384           // final product length truncation check
 385           int[] cdsRanges = adjustForProteinLength(translation.length(), exons);
 386           dnaToProteinMapping = new Mapping(product, cdsRanges, new int[] { 1,
 387               translation.length() }, 3, 1);
 388           if (product != null)
 389           {
 390             /*
 391              * make xrefs from protein to EMBLCDS and EMBLCDSPROTEIN
 392              */
 393             DBRefEntry proteinToEmblCdsRef = new DBRefEntry();
 394             proteinToEmblCdsRef.setAccessionId(proteinId);
 395             proteinToEmblCdsRef.setSource(DBRefSource.EMBLCDS);
 396             proteinToEmblCdsRef.setVersion(getSequenceVersion()); // same as
 397                                                                   // parent EMBL
 398             // version.
 399             MapList mp = new MapList(new int[] { 1, translation.length() },
 400                     new int[] { 1 + (codonStart - 1),
 401                         (codonStart - 1) + 3 * translation.length() }, 1, 3);
 402             proteinToEmblCdsRef.setMap(new Mapping(mp));
 403             product.addDBRef(proteinToEmblCdsRef);
 404             proteinToEmblProteinRef = new DBRefEntry(proteinToEmblCdsRef);
 405             MapList mp2 = new MapList(
 406                     new int[] { 1, translation.length() }, new int[] { 1,
 407                         translation.length() }, 1, 1);
 408             proteinToEmblProteinRef.setMap(new Mapping(mp2));
 409             proteinToEmblProteinRef.setSource(DBRefSource.EMBLCDSProduct);
 410             product.addDBRef(proteinToEmblProteinRef);
 411           }
 412         }
 413       }
 414
 415       /*
 416        * add cds features to dna sequence
 417        */
 418       for (int xint = 0; exons != null && xint < exons.length; xint += 2)
 419       {
 420         SequenceFeature sf = makeCdsFeature(exons, xint, proteinName, proteinId, vals,
 421                 codonStart);
 422         sf.setType(feature.getName()); // "CDS"
 423         sf.setEnaLocation(feature.getLocation());
 424         sf.setFeatureGroup(sourceDb);
 425         dna.addSequenceFeature(sf);
 426       }
 427     }
 428
 429     /*
 430      * add feature dbRefs to sequence, and mappings for Uniprot xrefs
 431      */
 432     boolean hasUniprotDbref = false;
 433     if (feature.dbRefs != null)
 434     {
 435       boolean mappingUsed = false;
 436       for (DBRefEntry ref : feature.dbRefs)
 437       {
 438         /*
 439          * ensure UniProtKB/Swiss-Prot converted to UNIPROT
 440          */
 441         String source = DBRefUtils.getCanonicalName(ref.getSource());
 442         ref.setSource(source);
 443         DBRefEntry proteinToDnaRef = new DBRefEntry(ref.getSource(), ref.getVersion(), ref
 444                 .getAccessionId());
 445         if (source.equals(DBRefSource.UNIPROT))
 446         {
 447           String proteinSeqName = DBRefSource.UNIPROT + "|"
 448                   + ref.getAccessionId();
 449           if (dnaToProteinMapping != null && dnaToProteinMapping.getTo() != null)
 450           {
 451             if (mappingUsed)
 452             {
 453               /*
 454                * two or more Uniprot xrefs for the same CDS -
 455                * each needs a distinct Mapping (as to a different sequence)
 456                */
 457               dnaToProteinMapping = new Mapping(dnaToProteinMapping);
 458             }
 459             mappingUsed = true;
 460
 461             /*
 462              * try to locate the protein mapped to (possibly by a
 463              * previous CDS feature); if not found, construct it from
 464              * the EMBL translation
 465              */
 466             SequenceI proteinSeq = matcher.findIdMatch(proteinSeqName);
 467             if (proteinSeq == null)
 468             {
 469               proteinSeq = new Sequence(proteinSeqName,
 470                       product.getSequenceAsString());
 471               matcher.add(proteinSeq);
 472               peptides.add(proteinSeq);
 473             }
 474             dnaToProteinMapping.setTo(proteinSeq);
 475             proteinSeq.addDBRef(proteinToDnaRef);
 476             ref.setMap(dnaToProteinMapping);
 477           }
 478           hasUniprotDbref = true;
 479         }
 480         if (product != null)
 481         {
 482           /*
 483            * copy feature dbref to our protein product
 484            */
 485           DBRefEntry pref = proteinToDnaRef;
 486           pref.setMap(null); // reference is direct
 487           product.addDBRef(pref);
 488           // Add converse mapping reference
 489           if (dnaToProteinMapping != null)
 490           {
 491             Mapping pmap = new Mapping(dna, dnaToProteinMapping.getMap()
 492                     .getInverse());
 493             pref = new DBRefEntry(sourceDb, getSequenceVersion(),
 494                     this.getAccession());
 495             pref.setMap(pmap);
 496             if (dnaToProteinMapping.getTo() != null)
 497             {
 498               dnaToProteinMapping.getTo().addDBRef(pref);
 499             }
 500           }
 501         }
 502         dna.addDBRef(ref);
 503       }
 504     }
 505     /*
 506      * if we have a product (translation) but no explicit Uniprot dbref
 507      * (example: EMBL AAFI02000057 protein_id EAL65544.1
 508      * construct mappings to an assumed EMBLCDSPROTEIN accession
 509      */
 510     if (!hasUniprotDbref && product != null)
 511     {
 512       if (proteinToEmblProteinRef == null)
 513       {
 514         proteinToEmblProteinRef = new DBRefEntry();
 515         proteinToEmblProteinRef.setAccessionId(proteinId);
 516         proteinToEmblProteinRef.setSource(DBRefSource.EMBLCDSProduct);
 517         proteinToEmblProteinRef.setVersion(getSequenceVersion());
 518         proteinToEmblProteinRef.setMap(new Mapping(product,
 519                 dnaToProteinMapping.getMap().getInverse()));
 520       }
 521       product.addDBRef(proteinToEmblProteinRef);
 522
 523       if (dnaToProteinMapping != null
 524               && dnaToProteinMapping.getTo() != null)
 525       {
 526         DBRefEntry dnaToEmblProteinRef = new DBRefEntry(
 527                 proteinToEmblProteinRef);
 528         dnaToEmblProteinRef.setMap(dnaToProteinMapping);
 529         dna.addDBRef(dnaToEmblProteinRef);
 530       }
 531     }
 532   }
 533
 534   /**
 535    * Helper method to construct a SequenceFeature for one cds range
 536    *
 537    * @param exons
 538    *          array of cds [start, end, ...] positions
 539    * @param exonStartIndex
 540    *          offset into the exons array
 541    * @param proteinName
 542    * @param proteinAccessionId
 543    * @param vals
 544    *          map of 'miscellaneous values' for feature
 545    * @param codonStart
 546    *          codon start position for CDS (1/2/3, normally 1)
 547    * @return
 548    */
 549   protected SequenceFeature makeCdsFeature(int[] exons, int exonStartIndex,
 550           String proteinName, String proteinAccessionId,
 551           Map<String, String> vals, int codonStart)
 552   {
 553     int exonNumber = exonStartIndex / 2 + 1;
 554     SequenceFeature sf = new SequenceFeature();
 555     sf.setBegin(Math.min(exons[exonStartIndex], exons[exonStartIndex + 1]));
 556     sf.setEnd(Math.max(exons[exonStartIndex], exons[exonStartIndex + 1]));
 557     sf.setDescription(String.format("Exon %d for protein '%s' EMBLCDS:%s",
 558             exonNumber, proteinName, proteinAccessionId));
 559     sf.setPhase(String.valueOf(codonStart - 1));
 560     sf.setStrand(exons[exonStartIndex] <= exons[exonStartIndex + 1] ? "+"
 561             : "-");
 562     sf.setValue(FeatureProperties.EXONPOS, exonNumber);
 563     sf.setValue(FeatureProperties.EXONPRODUCT, proteinName);
 564     if (!vals.isEmpty())
 565     {
 566       StringBuilder sb = new StringBuilder();
 567       boolean first = true;
 568       for (Entry<String, String> val : vals.entrySet())
 569       {
 570         if (!first)
 571         {
 572           sb.append(";");
 573         }
 574         sb.append(val.getKey()).append("=").append(val.getValue());
 575         first = false;
 576         sf.setValue(val.getKey(), val.getValue());
 577       }
 578       sf.setAttributes(sb.toString());
 579     }
 580     return sf;
 581   }
 582
 583   /**
 584    * Returns the CDS positions as a single array of [start, end, start, end...]
 585    * positions. If on the reverse strand, these will be in descending order.
 586    *
 587    * @param feature
 588    * @return
 589    */
 590   protected int[] getCdsRanges(EmblFeature feature)
 591   {
 592     if (feature.location == null)
 593     {
 594       return new int[] {};
 595     }
 596
 597     try
 598     {
 599       List<int[]> ranges = DnaUtils.parseLocation(feature.location);
 600       return listToArray(ranges);
 601     } catch (ParseException e)
 602     {
 603       Cache.log.warn(String.format(
 604               "Not parsing inexact CDS location %s in ENA %s",
 605               feature.location, this.accession));
 606       return new int[] {};
 607     }
 608   }
 609
 610   /**
 611    * Converts a list of [start, end] ranges to a single array of [start, end,
 612    * start, end ...]
 613    *
 614    * @param ranges
 615    * @return
 616    */
 617   int[] listToArray(List<int[]> ranges)
 618   {
 619     int[] result = new int[ranges.size() * 2];
 620     int i = 0;
 621     for (int[] range : ranges)
 622     {
 623       result[i++] = range[0];
 624       result[i++] = range[1];
 625     }
 626     return result;
 627   }
 628
 629   /**
 630    * Truncates (if necessary) the exon intervals to match 3 times the length of
 631    * the protein; also accepts 3 bases longer (for stop codon not included in
 632    * protein)
 633    *
 634    * @param proteinLength
 635    * @param exon
 636    *          an array of [start, end, start, end...] intervals
 637    * @return the same array (if unchanged) or a truncated copy
 638    */
 639   static int[] adjustForProteinLength(int proteinLength, int[] exon)
 640   {
 641     if (proteinLength <= 0 || exon == null)
 642     {
 643       return exon;
 644     }
 645     int expectedCdsLength = proteinLength * 3;
 646     int exonLength = MappingUtils.getLength(Arrays.asList(exon));
 647
 648     /*
 649      * if exon length matches protein, or is shorter, or longer by the
 650      * length of a stop codon (3 bases), then leave it unchanged
 651      */
 652     if (expectedCdsLength >= exonLength
 653             || expectedCdsLength == exonLength - 3)
 654     {
 655       return exon;
 656     }
 657
 658     int origxon[];
 659     int sxpos = -1;
 660     int endxon = 0;
 661     origxon = new int[exon.length];
 662     System.arraycopy(exon, 0, origxon, 0, exon.length);
 663     int cdspos = 0;
 664     for (int x = 0; x < exon.length; x += 2)
 665     {
 666       cdspos += Math.abs(exon[x + 1] - exon[x]) + 1;
 667       if (expectedCdsLength <= cdspos)
 668       {
 669         // advanced beyond last codon.
 670         sxpos = x;
 671         if (expectedCdsLength != cdspos)
 672         {
 673           // System.err
 674           // .println("Truncating final exon interval on region by "
 675           // + (cdspos - cdslength));
 676         }
 677
 678         /*
 679          * shrink the final exon - reduce end position if forward
 680          * strand, increase it if reverse
 681          */
 682         if (exon[x + 1] >= exon[x])
 683         {
 684           endxon = exon[x + 1] - cdspos + expectedCdsLength;
 685         }
 686         else
 687         {
 688           endxon = exon[x + 1] + cdspos - expectedCdsLength;
 689         }
 690         break;
 691       }
 692     }
 693
 694     if (sxpos != -1)
 695     {
 696       // and trim the exon interval set if necessary
 697       int[] nxon = new int[sxpos + 2];
 698       System.arraycopy(exon, 0, nxon, 0, sxpos + 2);
 699       nxon[sxpos + 1] = endxon; // update the end boundary for the new exon
 700                                 // set
 701       exon = nxon;
 702     }
 703     return exon;
 704   }
 705
 706   public String getSequenceVersion()
 707   {
 708     return sequenceVersion;
 709   }
 710
 711   public void setSequenceVersion(String sequenceVersion)
 712   {
 713     this.sequenceVersion = sequenceVersion;
 714   }
 715
 716   public String getSequenceLength()
 717   {
 718     return sequenceLength;
 719   }
 720
 721   public void setSequenceLength(String sequenceLength)
 722   {
 723     this.sequenceLength = sequenceLength;
 724   }
 725
 726   public String getEntryVersion()
 727   {
 728     return entryVersion;
 729   }
 730
 731   public void setEntryVersion(String entryVersion)
 732   {
 733     this.entryVersion = entryVersion;
 734   }
 735
 736   public String getMoleculeType()
 737   {
 738     return moleculeType;
 739   }
 740
 741   public void setMoleculeType(String moleculeType)
 742   {
 743     this.moleculeType = moleculeType;
 744   }
 745
 746   public String getTopology()
 747   {
 748     return topology;
 749   }
 750
 751   public void setTopology(String topology)
 752   {
 753     this.topology = topology;
 754   }
 755
 756   public String getTaxonomicDivision()
 757   {
 758     return taxonomicDivision;
 759   }
 760
 761   public void setTaxonomicDivision(String taxonomicDivision)
 762   {
 763     this.taxonomicDivision = taxonomicDivision;
 764   }
 765
 766   public String getDescription()
 767   {
 768     return description;
 769   }
 770
 771   public void setDescription(String description)
 772   {
 773     this.description = description;
 774   }
 775
 776   public String getFirstPublicDate()
 777   {
 778     return firstPublicDate;
 779   }
 780
 781   public void setFirstPublicDate(String firstPublicDate)
 782   {
 783     this.firstPublicDate = firstPublicDate;
 784   }
 785
 786   public String getFirstPublicRelease()
 787   {
 788     return firstPublicRelease;
 789   }
 790
 791   public void setFirstPublicRelease(String firstPublicRelease)
 792   {
 793     this.firstPublicRelease = firstPublicRelease;
 794   }
 795
 796   public String getLastUpdatedDate()
 797   {
 798     return lastUpdatedDate;
 799   }
 800
 801   public void setLastUpdatedDate(String lastUpdatedDate)
 802   {
 803     this.lastUpdatedDate = lastUpdatedDate;
 804   }
 805
 806   public String getLastUpdatedRelease()
 807   {
 808     return lastUpdatedRelease;
 809   }
 810
 811   public void setLastUpdatedRelease(String lastUpdatedRelease)
 812   {
 813     this.lastUpdatedRelease = lastUpdatedRelease;
 814   }
 815
 816   public String getDataClass()
 817   {
 818     return dataClass;
 819   }
 820
 821   public void setDataClass(String dataClass)
 822   {
 823     this.dataClass = dataClass;
 824   }
 825 }