src/jalview/ws/DBRefFetcher.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.ws;
  22
  23 import jalview.analysis.AlignSeq;
  24 import jalview.bin.Cache;
  25 import jalview.datamodel.AlignmentI;
  26 import jalview.datamodel.DBRefEntry;
  27 import jalview.datamodel.DBRefSource;
  28 import jalview.datamodel.Mapping;
  29 import jalview.datamodel.SequenceFeature;
  30 import jalview.datamodel.SequenceI;
  31 import jalview.gui.CutAndPasteTransfer;
  32 import jalview.gui.DasSourceBrowser;
  33 import jalview.gui.Desktop;
  34 import jalview.gui.FeatureSettings;
  35 import jalview.gui.IProgressIndicator;
  36 import jalview.gui.OOMWarning;
  37 import jalview.util.DBRefUtils;
  38 import jalview.util.MessageManager;
  39 import jalview.ws.dbsources.das.api.jalviewSourceI;
  40 import jalview.ws.dbsources.das.datamodel.DasSequenceSource;
  41 import jalview.ws.seqfetcher.DbSourceProxy;
  42
  43 import java.util.ArrayList;
  44 import java.util.Arrays;
  45 import java.util.Enumeration;
  46 import java.util.Hashtable;
  47 import java.util.List;
  48 import java.util.StringTokenizer;
  49 import java.util.Vector;
  50
  51 import uk.ac.ebi.picr.model.UPEntry;
  52 import uk.ac.ebi.www.picr.AccessionMappingService.AccessionMapperServiceLocator;
  53
  54 /**
  55  * Implements a runnable for validating a sequence against external databases
  56  * and then propagating references and features onto the sequence(s)
  57  *
  58  * @author $author$
  59  * @version $Revision$
  60  */
  61 public class DBRefFetcher implements Runnable
  62 {
  63   private static final String NEWLINE = System.lineSeparator();
  64
  65   public interface FetchFinishedListenerI
  66   {
  67     void finished();
  68   }
  69
  70   SequenceI[] dataset;
  71
  72   IProgressIndicator progressWindow;
  73
  74   CutAndPasteTransfer output = new CutAndPasteTransfer();
  75
  76   boolean running = false;
  77
  78   /**
  79    * picr client instance
  80    */
  81   uk.ac.ebi.www.picr.AccessionMappingService.AccessionMapperInterface picrClient = null;
  82
  83   // This will be a collection of Vectors of sequenceI refs.
  84   // The key will be the seq name or accession id of the seq
  85   Hashtable<String, Vector<SequenceI>> seqRefs;
  86
  87   DbSourceProxy[] dbSources;
  88
  89   SequenceFetcher sfetcher;
  90
  91   private List<FetchFinishedListenerI> listeners;
  92
  93   private SequenceI[] alseqs;
  94
  95   /*
  96    * when true - retrieved sequences will be trimmed to cover longest derived
  97    * alignment sequence
  98    */
  99   private boolean trimDsSeqs = true;
 100
 101   /**
 102    * Creates a new DBRefFetcher object and fetches from the currently selected
 103    * set of databases, if this is null then it fetches based on feature settings
 104    *
 105    * @param seqs
 106    *          fetch references for these SequenceI array
 107    * @param progressIndicatorFrame
 108    *          the frame for progress bar monitoring
 109    * @param sources
 110    *          array of DbSourceProxy to query references form
 111    * @param featureSettings
 112    *          FeatureSettings to get alternative DbSourceProxy from
 113    * @param isNucleotide
 114    *          indicates if the array of SequenceI are Nucleotides or not
 115    */
 116   public DBRefFetcher(SequenceI[] seqs,
 117           IProgressIndicator progressIndicatorFrame,
 118           DbSourceProxy[] sources, FeatureSettings featureSettings,
 119           boolean isNucleotide)
 120   {
 121     listeners = new ArrayList<FetchFinishedListenerI>();
 122     this.progressWindow = progressIndicatorFrame;
 123     alseqs = new SequenceI[seqs.length];
 124     SequenceI[] ds = new SequenceI[seqs.length];
 125     for (int i = 0; i < seqs.length; i++)
 126     {
 127       alseqs[i] = seqs[i];
 128       if (seqs[i].getDatasetSequence() != null)
 129       {
 130         ds[i] = seqs[i].getDatasetSequence();
 131       }
 132       else
 133       {
 134         ds[i] = seqs[i];
 135       }
 136     }
 137     this.dataset = ds;
 138     // TODO Jalview 2.5 lots of this code should be in the gui package!
 139     sfetcher = jalview.gui.SequenceFetcher
 140             .getSequenceFetcherSingleton(progressIndicatorFrame);
 141     // set default behaviour for transferring excess sequence data to the
 142     // dataset
 143     trimDsSeqs = Cache.getDefault("TRIM_FETCHED_DATASET_SEQS", true);
 144     if (sources == null)
 145     {
 146       setDatabaseSources(featureSettings, isNucleotide);
 147     }
 148     else
 149     {
 150       // we assume the caller knows what they're doing and ensured that all the
 151       // db source names are valid
 152       dbSources = sources;
 153     }
 154   }
 155
 156   /**
 157    * Helper method to configure the list of database sources to query
 158    *
 159    * @param featureSettings
 160    * @param forNucleotide
 161    */
 162   void setDatabaseSources(FeatureSettings featureSettings,
 163           boolean forNucleotide)
 164   {
 165     // af.featureSettings_actionPerformed(null);
 166     String[] defdb = null;
 167     List<DbSourceProxy> selsources = new ArrayList<DbSourceProxy>();
 168     Vector<jalviewSourceI> dasselsrc = (featureSettings != null) ? featureSettings
 169             .getSelectedSources() : new DasSourceBrowser()
 170             .getSelectedSources();
 171
 172     for (jalviewSourceI src : dasselsrc)
 173     {
 174       List<DbSourceProxy> sp = src.getSequenceSourceProxies();
 175       if (sp != null)
 176       {
 177         selsources.addAll(sp);
 178         if (sp.size() > 1)
 179         {
 180           Cache.log.debug("Added many Db Sources for :" + src.getTitle());
 181         }
 182       }
 183     }
 184     // select appropriate databases based on alignFrame context.
 185     if (forNucleotide)
 186     {
 187       defdb = DBRefSource.DNACODINGDBS;
 188     }
 189     else
 190     {
 191       defdb = DBRefSource.PROTEINDBS;
 192     }
 193     List<DbSourceProxy> srces = new ArrayList<DbSourceProxy>();
 194     for (String ddb : defdb)
 195     {
 196       List<DbSourceProxy> srcesfordb = sfetcher.getSourceProxy(ddb);
 197       if (srcesfordb != null)
 198       {
 199         for (DbSourceProxy src : srcesfordb)
 200         {
 201           if (!srces.contains(src))
 202           {
 203             srces.addAll(srcesfordb);
 204           }
 205         }
 206       }
 207     }
 208     // append the PDB data source, since it is 'special', catering for both
 209     // nucleotide and protein
 210     // srces.addAll(sfetcher.getSourceProxy(DBRefSource.PDB));
 211
 212     srces.addAll(selsources);
 213     dbSources = srces.toArray(new DbSourceProxy[srces.size()]);
 214   }
 215
 216   /**
 217    * Constructor with only sequences provided
 218    *
 219    * @param sequences
 220    */
 221   public DBRefFetcher(SequenceI[] sequences)
 222   {
 223     this(sequences, null, null, null, false);
 224   }
 225
 226   /**
 227    * Add a listener to be notified when sequence fetching is complete
 228    *
 229    * @param l
 230    */
 231   public void addListener(FetchFinishedListenerI l)
 232   {
 233     listeners.add(l);
 234   }
 235
 236   /**
 237    * retrieve all the das sequence sources and add them to the list of db
 238    * sources to retrieve from
 239    */
 240   public void appendAllDasSources()
 241   {
 242     if (dbSources == null)
 243     {
 244       dbSources = new DbSourceProxy[0];
 245     }
 246     // append additional sources
 247     DbSourceProxy[] otherdb = sfetcher
 248             .getDbSourceProxyInstances(DasSequenceSource.class);
 249     if (otherdb != null && otherdb.length > 0)
 250     {
 251       DbSourceProxy[] newsrc = new DbSourceProxy[dbSources.length
 252               + otherdb.length];
 253       System.arraycopy(dbSources, 0, newsrc, 0, dbSources.length);
 254       System.arraycopy(otherdb, 0, newsrc, dbSources.length, otherdb.length);
 255       dbSources = newsrc;
 256     }
 257   }
 258
 259   /**
 260    * start the fetcher thread
 261    *
 262    * @param waitTillFinished
 263    *          true to block until the fetcher has finished
 264    */
 265   public void fetchDBRefs(boolean waitTillFinished)
 266   {
 267     // TODO can we not simply write
 268     // if (waitTillFinished) { run(); } else { new Thread(this).start(); }
 269
 270     Thread thread = new Thread(this);
 271     thread.start();
 272     running = true;
 273
 274     if (waitTillFinished)
 275     {
 276       while (running)
 277       {
 278         try
 279         {
 280           Thread.sleep(500);
 281         } catch (Exception ex)
 282         {
 283         }
 284       }
 285     }
 286   }
 287
 288   /**
 289    * The sequence will be added to a vector of sequences belonging to key which
 290    * could be either seq name or dbref id
 291    *
 292    * @param seq
 293    *          SequenceI
 294    * @param key
 295    *          String
 296    */
 297   void addSeqId(SequenceI seq, String key)
 298   {
 299     key = key.toUpperCase();
 300
 301     Vector<SequenceI> seqs;
 302     if (seqRefs.containsKey(key))
 303     {
 304       seqs = seqRefs.get(key);
 305
 306       if (seqs != null && !seqs.contains(seq))
 307       {
 308         seqs.addElement(seq);
 309       }
 310       else if (seqs == null)
 311       {
 312         seqs = new Vector<SequenceI>();
 313         seqs.addElement(seq);
 314       }
 315
 316     }
 317     else
 318     {
 319       seqs = new Vector<SequenceI>();
 320       seqs.addElement(seq);
 321     }
 322
 323     seqRefs.put(key, seqs);
 324   }
 325
 326   /**
 327    * DOCUMENT ME!
 328    */
 329   @Override
 330   public void run()
 331   {
 332     if (dbSources == null)
 333     {
 334       throw new Error(
 335               MessageManager
 336                       .getString("error.implementation_error_must_init_dbsources"));
 337     }
 338     running = true;
 339     long startTime = System.currentTimeMillis();
 340     if (progressWindow != null)
 341     {
 342       progressWindow.setProgressBar(
 343               MessageManager.getString("status.fetching_db_refs"),
 344               startTime);
 345     }
 346     try
 347     {
 348       if (Cache.getDefault("DBREFFETCH_USEPICR", false))
 349       {
 350         picrClient = new AccessionMapperServiceLocator()
 351                 .getAccessionMapperPort();
 352       }
 353     } catch (Exception e)
 354     {
 355       System.err.println("Couldn't locate PICR service instance.\n");
 356       e.printStackTrace();
 357     }
 358
 359     Vector<SequenceI> sdataset = new Vector<SequenceI>(
 360             Arrays.asList(dataset));
 361     List<String> warningMessages = new ArrayList<String>();
 362
 363     int db = 0;
 364     while (sdataset.size() > 0 && db < dbSources.length)
 365     {
 366       int maxqlen = 1; // default number of queries made at one time
 367       System.out.println("Verifying against " + dbSources[db].getDbName());
 368
 369       // iterate through db for each remaining un-verified sequence
 370       SequenceI[] currSeqs = new SequenceI[sdataset.size()];
 371       sdataset.copyInto(currSeqs);// seqs that are to be validated against
 372       // dbSources[db]
 373       Vector<String> queries = new Vector<String>(); // generated queries curSeq
 374       seqRefs = new Hashtable<String, Vector<SequenceI>>();
 375
 376       int seqIndex = 0;
 377
 378       DbSourceProxy dbsource = dbSources[db];
 379       // for moment, we dumbly iterate over all retrieval sources for a
 380       // particular database
 381       // TODO: introduce multithread multisource queries and logic to remove a
 382       // query from other sources if any source for a database returns a
 383       // record
 384       maxqlen = dbsource.getMaximumQueryCount();
 385
 386       while (queries.size() > 0 || seqIndex < currSeqs.length)
 387       {
 388         if (queries.size() > 0)
 389         {
 390           // Still queries to make for current seqIndex
 391           StringBuffer queryString = new StringBuffer("");
 392           int numq = 0;
 393           int nqSize = (maxqlen > queries.size()) ? queries.size()
 394                   : maxqlen;
 395
 396           while (queries.size() > 0 && numq < nqSize)
 397           {
 398             String query = queries.elementAt(0);
 399             if (dbsource.isValidReference(query))
 400             {
 401               queryString.append((numq == 0) ? "" : dbsource
 402                       .getAccessionSeparator());
 403               queryString.append(query);
 404               numq++;
 405             }
 406             // remove the extracted query string
 407             queries.removeElementAt(0);
 408           }
 409           // make the queries and process the response
 410           AlignmentI retrieved = null;
 411           try
 412           {
 413             if (Cache.log.isDebugEnabled())
 414             {
 415               Cache.log.debug("Querying " + dbsource.getDbName()
 416                       + " with : '" + queryString.toString() + "'");
 417             }
 418             retrieved = dbsource.getSequenceRecords(queryString.toString());
 419           } catch (Exception ex)
 420           {
 421             ex.printStackTrace();
 422           } catch (OutOfMemoryError err)
 423           {
 424             new OOMWarning("retrieving database references ("
 425                     + queryString.toString() + ")", err);
 426           }
 427           if (retrieved != null)
 428           {
 429             transferReferences(sdataset, dbsource.getDbSource(), retrieved,
 430                     trimDsSeqs, warningMessages);
 431           }
 432         }
 433         else
 434         {
 435           // make some more strings for use as queries
 436           for (int i = 0; (seqIndex < dataset.length) && (i < 50); seqIndex++, i++)
 437           {
 438             SequenceI sequence = dataset[seqIndex];
 439             DBRefEntry[] uprefs = DBRefUtils.selectRefs(
 440                     sequence.getDBRefs(),
 441                     new String[] { dbsource.getDbSource() }); // jalview.datamodel.DBRefSource.UNIPROT
 442             // });
 443             // check for existing dbrefs to use
 444             if (uprefs != null && uprefs.length > 0)
 445             {
 446               for (int j = 0; j < uprefs.length; j++)
 447               {
 448                 addSeqId(sequence, uprefs[j].getAccessionId());
 449                 queries.addElement(uprefs[j].getAccessionId().toUpperCase());
 450               }
 451             }
 452             else
 453             {
 454               // generate queries from sequence ID string
 455               StringTokenizer st = new StringTokenizer(sequence.getName(),
 456                       "|");
 457               while (st.hasMoreTokens())
 458               {
 459                 String token = st.nextToken();
 460                 UPEntry[] presp = null;
 461                 if (picrClient != null)
 462                 {
 463                   // resolve the string against PICR to recover valid IDs
 464                   try
 465                   {
 466                     presp = picrClient
 467                             .getUPIForAccession(token, null,
 468                                     picrClient.getMappedDatabaseNames(),
 469                                     null, true);
 470                   } catch (Exception e)
 471                   {
 472                     System.err.println("Exception with Picr for '" + token
 473                             + "'\n");
 474                     e.printStackTrace();
 475                   }
 476                 }
 477                 if (presp != null && presp.length > 0)
 478                 {
 479                   for (int id = 0; id < presp.length; id++)
 480                   {
 481                     // construct sequences from response if sequences are
 482                     // present, and do a transferReferences
 483                     // otherwise transfer non sequence x-references directly.
 484                   }
 485                   System.out
 486                           .println("Validated ID against PICR... (for what its worth):"
 487                                   + token);
 488                   addSeqId(sequence, token);
 489                   queries.addElement(token.toUpperCase());
 490                 }
 491                 else
 492                 {
 493                   // if ()
 494                   // System.out.println("Not querying source with token="+token+"\n");
 495                   addSeqId(sequence, token);
 496                   queries.addElement(token.toUpperCase());
 497                 }
 498               }
 499             }
 500           }
 501         }
 502       }
 503       // advance to next database
 504       db++;
 505     } // all databases have been queried
 506     if (!warningMessages.isEmpty())
 507     {
 508       StringBuilder sb = new StringBuilder(warningMessages.size() * 30);
 509       sb.append(MessageManager
 510               .getString("label.your_sequences_have_been_verified"));
 511       for (String msg : warningMessages)
 512       {
 513         sb.append(msg).append(NEWLINE);
 514       }
 515       output.setText(sb.toString());
 516
 517       Desktop.addInternalFrame(output,
 518               MessageManager.getString("label.sequences_updated"), 600, 300);
 519       // The above is the dataset, we must now find out the index
 520       // of the viewed sequence
 521
 522     }
 523     if (progressWindow != null)
 524     {
 525       progressWindow.setProgressBar(
 526               MessageManager.getString("label.dbref_search_completed"),
 527               startTime);
 528     }
 529
 530     for (FetchFinishedListenerI listener : listeners)
 531     {
 532       listener.finished();
 533     }
 534     running = false;
 535   }
 536
 537   /**
 538    * Verify local sequences in seqRefs against the retrieved sequence database
 539    * records. Returns true if any sequence was modified as a result (start/end
 540    * changed and/or sequence enlarged), else false.
 541    *
 542    * @param sdataset
 543    *          dataset sequences we are retrieving for
 544    * @param dbSource
 545    *          database source we are retrieving from
 546    * @param retrievedAl
 547    *          retrieved sequences as alignment
 548    * @param trimDatasetSeqs
 549    *          if true, sequences will not be enlarged to match longer retrieved
 550    *          sequences, only their start/end adjusted
 551    * @param warningMessages
 552    *          a list of messages to add to
 553    */
 554   boolean transferReferences(Vector<SequenceI> sdataset, String dbSource,
 555           AlignmentI retrievedAl, boolean trimDatasetSeqs,
 556           List<String> warningMessages)
 557   {
 558     // System.out.println("trimming ? " + trimDatasetSeqs);
 559     if (retrievedAl == null || retrievedAl.getHeight() == 0)
 560     {
 561       return false;
 562     }
 563
 564     boolean modified = false;
 565     SequenceI[] retrieved = recoverDbSequences(retrievedAl
 566             .getSequencesArray());
 567     SequenceI sequence = null;
 568
 569     for (SequenceI retrievedSeq : retrieved)
 570     {
 571       // Work out which sequences this sequence matches,
 572       // taking into account all accessionIds and names in the file
 573       Vector<SequenceI> sequenceMatches = new Vector<SequenceI>();
 574       // look for corresponding accession ids
 575       DBRefEntry[] entryRefs = DBRefUtils.selectRefs(
 576               retrievedSeq.getDBRefs(), new String[] { dbSource });
 577       if (entryRefs == null)
 578       {
 579         System.err
 580                 .println("Dud dbSource string ? no entryrefs selected for "
 581                         + dbSource + " on " + retrievedSeq.getName());
 582         continue;
 583       }
 584       for (int j = 0; j < entryRefs.length; j++)
 585       {
 586         String accessionId = entryRefs[j].getAccessionId();
 587         // match up on accessionId
 588         if (seqRefs.containsKey(accessionId.toUpperCase()))
 589         {
 590           Vector<SequenceI> seqs = seqRefs.get(accessionId);
 591           for (int jj = 0; jj < seqs.size(); jj++)
 592           {
 593             sequence = seqs.elementAt(jj);
 594             if (!sequenceMatches.contains(sequence))
 595             {
 596               sequenceMatches.addElement(sequence);
 597             }
 598           }
 599         }
 600       }
 601       if (sequenceMatches.isEmpty())
 602       {
 603         // failed to match directly on accessionId==query so just compare all
 604         // sequences to entry
 605         Enumeration<String> e = seqRefs.keys();
 606         while (e.hasMoreElements())
 607         {
 608           Vector<SequenceI> sqs = seqRefs.get(e.nextElement());
 609           if (sqs != null && sqs.size() > 0)
 610           {
 611             Enumeration<SequenceI> sqe = sqs.elements();
 612             while (sqe.hasMoreElements())
 613             {
 614               sequenceMatches.addElement(sqe.nextElement());
 615             }
 616           }
 617         }
 618       }
 619       // look for corresponding names
 620       // this is uniprot specific ?
 621       // could be useful to extend this so we try to find any 'significant'
 622       // information in common between two sequence objects.
 623       /*
 624        * DBRefEntry[] entryRefs =
 625        * jalview.util.DBRefUtils.selectRefs(entry.getDBRef(), new String[] {
 626        * dbSource }); for (int j = 0; j < entry.getName().size(); j++) { String
 627        * name = entry.getName().elementAt(j).toString(); if
 628        * (seqRefs.containsKey(name)) { Vector seqs = (Vector) seqRefs.get(name);
 629        * for (int jj = 0; jj < seqs.size(); jj++) { sequence = (SequenceI)
 630        * seqs.elementAt(jj); if (!sequenceMatches.contains(sequence)) {
 631        * sequenceMatches.addElement(sequence); } } } }
 632        */
 633       // sequenceMatches now contains the set of all sequences associated with
 634       // the returned db record
 635       final String retrievedSeqString = retrievedSeq.getSequenceAsString();
 636       String entrySeq = retrievedSeqString.toUpperCase();
 637       for (int m = 0; m < sequenceMatches.size(); m++)
 638       {
 639         sequence = sequenceMatches.elementAt(m);
 640         // only update start and end positions and shift features if there are
 641         // no existing references
 642         // TODO: test for legacy where uniprot or EMBL refs exist but no
 643         // mappings are made (but content matches retrieved set)
 644         boolean updateRefFrame = sequence.getDBRefs() == null
 645                 || sequence.getDBRefs().length == 0;
 646         // TODO:
 647         // verify sequence against the entry sequence
 648
 649         Mapping mp;
 650         final int sequenceStart = sequence.getStart();
 651
 652         boolean remoteEnclosesLocal = false;
 653         String nonGapped = AlignSeq.extractGaps("-. ",
 654                 sequence.getSequenceAsString()).toUpperCase();
 655         int absStart = entrySeq.indexOf(nonGapped);
 656         if (absStart == -1)
 657         {
 658           // couldn't find local sequence in sequence from database, so check if
 659           // the database sequence is a subsequence of local sequence
 660           absStart = nonGapped.indexOf(entrySeq);
 661           if (absStart == -1)
 662           {
 663             // verification failed. couldn't find any relationship between
 664             // entrySeq and local sequence
 665             // messages suppressed as many-to-many matches are confusing
 666             // String msg = sequence.getName()
 667             // + " Sequence not 100% match with "
 668             // + retrievedSeq.getName();
 669             // addWarningMessage(warningMessages, msg);
 670             continue;
 671           }
 672           /*
 673            * retrieved sequence is a proper subsequence of local sequence
 674            */
 675           String msg = sequence.getName() + " has " + absStart
 676                   + " prefixed residues compared to "
 677                   + retrievedSeq.getName();
 678           addWarningMessage(warningMessages, msg);
 679
 680           /*
 681            * So create a mapping to the external entry from the matching region of
 682            * the local sequence, and leave local start/end untouched.
 683            */
 684           mp = new Mapping(null, new int[] { sequenceStart + absStart,
 685               sequenceStart + absStart + entrySeq.length() - 1 }, new int[]
 686           { retrievedSeq.getStart(),
 687               retrievedSeq.getStart() + entrySeq.length() - 1 }, 1, 1);
 688           updateRefFrame = false;
 689         }
 690         else
 691         {
 692           /*
 693            * local sequence is a subsequence of (or matches) retrieved sequence
 694            */
 695           remoteEnclosesLocal = true;
 696           mp = null;
 697
 698           if (updateRefFrame)
 699           {
 700             SequenceFeature[] sfs = sequence.getSequenceFeatures();
 701             if (sfs != null)
 702             {
 703               /*
 704                * relocate existing sequence features by offset
 705                */
 706               int start = sequenceStart;
 707               int end = sequence.getEnd();
 708               int startShift = 1 - absStart - start;
 709
 710               if (startShift != 0)
 711               {
 712                 for (SequenceFeature sf : sfs)
 713                 {
 714                   if (sf.getBegin() >= start && sf.getEnd() <= end)
 715                   {
 716                     sf.setBegin(sf.getBegin() + startShift);
 717                     sf.setEnd(sf.getEnd() + startShift);
 718                     modified = true;
 719                   }
 720                 }
 721               }
 722             }
 723           }
 724         }
 725
 726         System.out.println("Adding dbrefs to " + sequence.getName()
 727                 + " from " + dbSource + " sequence : "
 728                 + retrievedSeq.getName());
 729         sequence.transferAnnotation(retrievedSeq, mp);
 730
 731         absStart += retrievedSeq.getStart();
 732         int absEnd = absStart + nonGapped.length() - 1;
 733         if (!trimDatasetSeqs)
 734         {
 735           /*
 736            * update start position and/or expand to longer retrieved sequence
 737            */
 738           if (!retrievedSeqString.equals(sequence.getSequenceAsString())
 739                   && remoteEnclosesLocal)
 740           {
 741             sequence.setSequence(retrievedSeqString);
 742             modified = true;
 743             addWarningMessage(warningMessages,
 744                     "Sequence for " + sequence.getName()
 745                             + " expanded from " + retrievedSeq.getName());
 746           }
 747           if (sequence.getStart() != retrievedSeq.getStart())
 748           {
 749             sequence.setStart(retrievedSeq.getStart());
 750             modified = true;
 751             if (absStart != sequenceStart)
 752             {
 753               addWarningMessage(warningMessages, "Start/end position for "
 754                       + sequence.getName() + " updated from "
 755                       + retrievedSeq.getName());
 756             }
 757           }
 758         }
 759         if (updateRefFrame)
 760         {
 761           // finally, update local sequence reference frame if we're allowed
 762           if (trimDatasetSeqs)
 763           {
 764             // just fix start/end
 765             if (sequence.getStart() != absStart
 766                     || sequence.getEnd() != absEnd)
 767             {
 768               sequence.setStart(absStart);
 769               sequence.setEnd(absEnd);
 770               modified = true;
 771               addWarningMessage(warningMessages, "Start/end for "
 772                       + sequence.getName() + " updated from "
 773                       + retrievedSeq.getName());
 774             }
 775           }
 776           // search for alignment sequences to update coordinate frame for
 777           for (int alsq = 0; alsq < alseqs.length; alsq++)
 778           {
 779             if (alseqs[alsq].getDatasetSequence() == sequence)
 780             {
 781               String ngAlsq = AlignSeq.extractGaps("-. ",
 782                       alseqs[alsq].getSequenceAsString()).toUpperCase();
 783               int oldstrt = alseqs[alsq].getStart();
 784               alseqs[alsq].setStart(sequence.getSequenceAsString()
 785                       .toUpperCase().indexOf(ngAlsq)
 786                       + sequence.getStart());
 787               if (oldstrt != alseqs[alsq].getStart())
 788               {
 789                 alseqs[alsq].setEnd(ngAlsq.length()
 790                         + alseqs[alsq].getStart() - 1);
 791                 modified = true;
 792               }
 793             }
 794           }
 795           // TODO: search for all other references to this dataset sequence, and
 796           // update start/end
 797           // TODO: update all AlCodonMappings which involve this alignment
 798           // sequence (e.g. Q30167 cdna translation from exon2 product (vamsas
 799           // demo)
 800         }
 801         // and remove it from the rest
 802         // TODO: decide if we should remove annotated sequence from set
 803         sdataset.remove(sequence);
 804         // TODO: should we make a note of sequences that have received new DB
 805         // ids, so we can query all enabled DAS servers for them ?
 806       }
 807     }
 808     return modified;
 809   }
 810
 811   /**
 812    * Adds the message to the list unless it already contains it
 813    *
 814    * @param messageList
 815    * @param msg
 816    */
 817   void addWarningMessage(List<String> messageList, String msg)
 818   {
 819     if (!messageList.contains(msg))
 820     {
 821       messageList.add(msg);
 822     }
 823   }
 824
 825   /**
 826    * loop thru and collect additional sequences in Map.
 827    *
 828    * @param sequencesArray
 829    * @return
 830    */
 831   private SequenceI[] recoverDbSequences(SequenceI[] sequencesArray)
 832   {
 833     Vector<SequenceI> nseq = new Vector<SequenceI>();
 834     for (int i = 0; sequencesArray != null && i < sequencesArray.length; i++)
 835     {
 836       nseq.addElement(sequencesArray[i]);
 837       DBRefEntry[] dbr = sequencesArray[i].getDBRefs();
 838       Mapping map = null;
 839       for (int r = 0; (dbr != null) && r < dbr.length; r++)
 840       {
 841         if ((map = dbr[r].getMap()) != null)
 842         {
 843           if (map.getTo() != null && !nseq.contains(map.getTo()))
 844           {
 845             nseq.addElement(map.getTo());
 846           }
 847         }
 848       }
 849     }
 850     if (nseq.size() > 0)
 851     {
 852       sequencesArray = new SequenceI[nseq.size()];
 853       nseq.toArray(sequencesArray);
 854     }
 855     return sequencesArray;
 856   }
 857 }