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