src/jalview/ws/DBRefFetcher.java

   1 /*\r
   2  * Jalview - A Sequence Alignment Editor and Viewer (Development Version 2.4.1)\r
   3  * Copyright (C) 2009 AM Waterhouse, J Procter, G Barton, M Clamp, S Searle\r
   4  * \r
   5  * This program is free software; you can redistribute it and/or\r
   6  * modify it under the terms of the GNU General Public License\r
   7  * as published by the Free Software Foundation; either version 2\r
   8  * of the License, or (at your option) any later version.\r
   9  * \r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  * \r
  15  * You should have received a copy of the GNU General Public License\r
  16  * along with this program; if not, write to the Free Software\r
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA\r
  18  */\r
  19 package jalview.ws;\r
  20 \r
  21 import jalview.analysis.AlignSeq;\r
  22 import jalview.bin.Cache;\r
  23 import jalview.datamodel.AlignmentI;\r
  24 import jalview.datamodel.DBRefEntry;\r
  25 import jalview.datamodel.DBRefSource;\r
  26 import jalview.datamodel.Mapping;\r
  27 import jalview.datamodel.SequenceFeature;\r
  28 import jalview.datamodel.SequenceI;\r
  29 import jalview.gui.AlignFrame;\r
  30 import jalview.gui.CutAndPasteTransfer;\r
  31 import jalview.gui.Desktop;\r
  32 import jalview.gui.IProgressIndicator;\r
  33 import jalview.gui.OOMWarning;\r
  34 \r
  35 import java.lang.reflect.Array;\r
  36 import java.util.Enumeration;\r
  37 import java.util.Hashtable;\r
  38 import java.util.StringTokenizer;\r
  39 import java.util.Vector;\r
  40 \r
  41 import org.biojava.dasobert.dasregistry.DasSource;\r
  42 \r
  43 import uk.ac.ebi.picr.model.UPEntry;\r
  44 \r
  45 /**\r
  46  * Implements a runnable for validating a sequence against external databases\r
  47  * and then propagating references and features onto the sequence(s)\r
  48  * \r
  49  * @author $author$\r
  50  * @version $Revision$\r
  51  */\r
  52 public class DBRefFetcher implements Runnable\r
  53 {\r
  54   SequenceI[] dataset;\r
  55 \r
  56   IProgressIndicator af;\r
  57 \r
  58   CutAndPasteTransfer output = new CutAndPasteTransfer();\r
  59 \r
  60   StringBuffer sbuffer = new StringBuffer();\r
  61 \r
  62   boolean running = false;\r
  63 \r
  64   /**\r
  65    * picr client instance\r
  66    */\r
  67   uk.ac.ebi.www.picr.AccessionMappingService.AccessionMapperInterface picrClient = null;\r
  68 \r
  69   // /This will be a collection of Vectors of sequenceI refs.\r
  70   // The key will be the seq name or accession id of the seq\r
  71   Hashtable seqRefs;\r
  72 \r
  73   String[] dbSources;\r
  74 \r
  75   SequenceFetcher sfetcher;\r
  76 \r
  77   public DBRefFetcher()\r
  78   {\r
  79   }\r
  80 \r
  81   /**\r
  82    * Creates a new SequenceFeatureFetcher object and fetches from the currently\r
  83    * selected set of databases.\r
  84    * \r
  85    * @param seqs\r
  86    *          fetch references for these sequences\r
  87    * @param af\r
  88    *          the parent alignframe for progress bar monitoring.\r
  89    */\r
  90   public DBRefFetcher(SequenceI[] seqs, AlignFrame af)\r
  91   {\r
  92     this(seqs, af, null);\r
  93   }\r
  94 \r
  95   /**\r
  96    * Creates a new SequenceFeatureFetcher object and fetches from the currently\r
  97    * selected set of databases.\r
  98    * \r
  99    * @param seqs\r
 100    *          fetch references for these sequences\r
 101    * @param af\r
 102    *          the parent alignframe for progress bar monitoring.\r
 103    * @param sources\r
 104    *          array of database source strings to query references from\r
 105    */\r
 106   public DBRefFetcher(SequenceI[] seqs, AlignFrame af, String[] sources)\r
 107   {\r
 108     this.af = af;\r
 109     SequenceI[] ds = new SequenceI[seqs.length];\r
 110     for (int i = 0; i < seqs.length; i++)\r
 111     {\r
 112       if (seqs[i].getDatasetSequence() != null)\r
 113         ds[i] = seqs[i].getDatasetSequence();\r
 114       else\r
 115         ds[i] = seqs[i];\r
 116     }\r
 117     this.dataset = ds;\r
 118     // TODO Jalview 2.5 lots of this code should be in the gui package!\r
 119     sfetcher = jalview.gui.SequenceFetcher.getSequenceFetcherSingleton(af);\r
 120     if (sources == null)\r
 121     {\r
 122       // af.featureSettings_actionPerformed(null);\r
 123       String[] defdb = null, otherdb = sfetcher\r
 124               .getDbInstances(jalview.ws.dbsources.DasSequenceSource.class);\r
 125       Vector selsources = new Vector(), dasselsrc = (af.featureSettings != null) ? af.featureSettings\r
 126               .getSelectedSources()\r
 127               : new jalview.gui.DasSourceBrowser().getSelectedSources();\r
 128       Enumeration en = dasselsrc.elements();\r
 129       while (en.hasMoreElements())\r
 130       {\r
 131         DasSource src = (DasSource) en.nextElement();\r
 132         selsources.addElement(src.getNickname());\r
 133       }\r
 134       int osel = 0;\r
 135       for (int o = 0; otherdb != null && o < otherdb.length; o++)\r
 136       {\r
 137         if (!selsources.contains(otherdb[o]))\r
 138         {\r
 139           otherdb[o] = null;\r
 140         }\r
 141         else\r
 142         {\r
 143           osel++;\r
 144         }\r
 145       }\r
 146       // select appropriate databases based on alignFrame context.\r
 147       if (af.getViewport().getAlignment().isNucleotide())\r
 148       {\r
 149         defdb = DBRefSource.DNACODINGDBS;\r
 150       }\r
 151       else\r
 152       {\r
 153         defdb = DBRefSource.PROTEINDBS;\r
 154       }\r
 155       // append the selected sequence sources to the default dbs\r
 156       dbSources = new String[defdb.length + osel];\r
 157       System.arraycopy(defdb, 0, dbSources, 0, defdb.length);\r
 158       for (int o = 0, op = defdb.length; otherdb != null\r
 159               && o < otherdb.length; o++)\r
 160       {\r
 161         if (otherdb[o] != null)\r
 162         {\r
 163           dbSources[op++] = otherdb[o];\r
 164         }\r
 165       }\r
 166     }\r
 167     else\r
 168     {\r
 169       // we assume the caller knows what they're doing and ensured that all the\r
 170       // db source names are valid\r
 171       dbSources = sources;\r
 172     }\r
 173   }\r
 174 \r
 175   /**\r
 176    * retrieve all the das sequence sources and add them to the list of db\r
 177    * sources to retrieve from\r
 178    */\r
 179   public void appendAllDasSources()\r
 180   {\r
 181     if (dbSources == null)\r
 182     {\r
 183       dbSources = new String[]\r
 184       {};\r
 185     }\r
 186     // append additional sources\r
 187     String[] otherdb = sfetcher\r
 188             .getDbInstances(jalview.ws.dbsources.DasSequenceSource.class);\r
 189     if (otherdb != null && otherdb.length > 0)\r
 190     {\r
 191       String[] newsrc = new String[dbSources.length + otherdb.length];\r
 192       System.arraycopy(dbSources, 0, newsrc, 0, dbSources.length);\r
 193       System\r
 194               .arraycopy(otherdb, 0, newsrc, dbSources.length,\r
 195                       otherdb.length);\r
 196       dbSources = newsrc;\r
 197     }\r
 198   }\r
 199 \r
 200   /**\r
 201    * start the fetcher thread\r
 202    * \r
 203    * @param waitTillFinished\r
 204    *          true to block until the fetcher has finished\r
 205    */\r
 206   public void fetchDBRefs(boolean waitTillFinished)\r
 207   {\r
 208     Thread thread = new Thread(this);\r
 209     thread.start();\r
 210     running = true;\r
 211 \r
 212     if (waitTillFinished)\r
 213     {\r
 214       while (running)\r
 215       {\r
 216         try\r
 217         {\r
 218           Thread.sleep(500);\r
 219         } catch (Exception ex)\r
 220         {\r
 221         }\r
 222       }\r
 223     }\r
 224   }\r
 225 \r
 226   /**\r
 227    * The sequence will be added to a vector of sequences belonging to key which\r
 228    * could be either seq name or dbref id\r
 229    * \r
 230    * @param seq\r
 231    *          SequenceI\r
 232    * @param key\r
 233    *          String\r
 234    */\r
 235   void addSeqId(SequenceI seq, String key)\r
 236   {\r
 237     key = key.toUpperCase();\r
 238 \r
 239     Vector seqs;\r
 240     if (seqRefs.containsKey(key))\r
 241     {\r
 242       seqs = (Vector) seqRefs.get(key);\r
 243 \r
 244       if (seqs != null && !seqs.contains(seq))\r
 245       {\r
 246         seqs.addElement(seq);\r
 247       }\r
 248       else if (seqs == null)\r
 249       {\r
 250         seqs = new Vector();\r
 251         seqs.addElement(seq);\r
 252       }\r
 253 \r
 254     }\r
 255     else\r
 256     {\r
 257       seqs = new Vector();\r
 258       seqs.addElement(seq);\r
 259     }\r
 260 \r
 261     seqRefs.put(key, seqs);\r
 262   }\r
 263 \r
 264   /**\r
 265    * DOCUMENT ME!\r
 266    */\r
 267   public void run()\r
 268   {\r
 269     if (dbSources == null)\r
 270     {\r
 271       throw new Error("Implementation error. Must initialise dbSources");\r
 272     }\r
 273     running = true;\r
 274     long startTime = System.currentTimeMillis();\r
 275     af.setProgressBar("Fetching db refs", startTime);\r
 276     try\r
 277     {\r
 278       if (Cache.getDefault("DBREFFETCH_USEPICR", false))\r
 279       {\r
 280         picrClient = new uk.ac.ebi.www.picr.AccessionMappingService.AccessionMapperServiceLocator()\r
 281                 .getAccessionMapperPort();\r
 282       }\r
 283     } catch (Exception e)\r
 284     {\r
 285       System.err.println("Couldn't locate PICR service instance.\n");\r
 286       e.printStackTrace();\r
 287     }\r
 288     int db = 0;\r
 289     Vector sdataset = new Vector();\r
 290     for (int s = 0; s < dataset.length; s++)\r
 291     {\r
 292       sdataset.addElement(dataset[s]);\r
 293     }\r
 294     while (sdataset.size() > 0 && db < dbSources.length)\r
 295     {\r
 296       int maxqlen = 1; // default number of queries made to at one time\r
 297       System.err.println("Verifying against " + dbSources[db]);\r
 298       jalview.ws.seqfetcher.DbSourceProxy dbsource = sfetcher\r
 299               .getSourceProxy(dbSources[db]);\r
 300       if (dbsource == null)\r
 301       {\r
 302         System.err.println("No proxy for " + dbSources[db]);\r
 303         db++;\r
 304         continue;\r
 305       }\r
 306       if (dbsource.getDbSourceProperties()\r
 307               .containsKey(DBRefSource.MULTIACC))\r
 308       {\r
 309         maxqlen = ((Integer) dbsource.getDbSourceProperties().get(\r
 310                 DBRefSource.MULTIACC)).intValue();\r
 311       }\r
 312       else\r
 313       {\r
 314         maxqlen = 1;\r
 315       }\r
 316       // iterate through db for each remaining un-verified sequence\r
 317       SequenceI[] currSeqs = new SequenceI[sdataset.size()];\r
 318       sdataset.copyInto(currSeqs);// seqs that are to be validated against\r
 319       // dbSources[db]\r
 320       Vector queries = new Vector(); // generated queries curSeq\r
 321       seqRefs = new Hashtable();\r
 322 \r
 323       int seqIndex = 0;\r
 324 \r
 325       while (queries.size() > 0 || seqIndex < currSeqs.length)\r
 326       {\r
 327         if (queries.size() > 0)\r
 328         {\r
 329           // Still queries to make for current seqIndex\r
 330           StringBuffer queryString = new StringBuffer("");\r
 331           int numq = 0, nqSize = (maxqlen > queries.size()) ? queries\r
 332                   .size() : maxqlen;\r
 333 \r
 334           while (queries.size() > 0 && numq < nqSize)\r
 335           {\r
 336             String query = (String) queries.elementAt(0);\r
 337             if (dbsource.isValidReference(query))\r
 338             {\r
 339               queryString.append((numq == 0) ? "" : dbsource\r
 340                       .getAccessionSeparator());\r
 341               queryString.append(query);\r
 342               numq++;\r
 343             }\r
 344             // remove the extracted query string\r
 345             queries.removeElementAt(0);\r
 346           }\r
 347           // make the queries and process the response\r
 348           AlignmentI retrieved = null;\r
 349           try\r
 350           {\r
 351             if (jalview.bin.Cache.log.isDebugEnabled())\r
 352             {\r
 353               jalview.bin.Cache.log.debug("Querying "\r
 354                       + dbsource.getDbName() + " with : '"\r
 355                       + queryString.toString() + "'");\r
 356             }\r
 357             retrieved = dbsource.getSequenceRecords(queryString.toString());\r
 358           } catch (Exception ex)\r
 359           {\r
 360             ex.printStackTrace();\r
 361           } catch (OutOfMemoryError err)\r
 362           {\r
 363             new OOMWarning("retrieving database references ("\r
 364                     + queryString.toString() + ")", err);\r
 365           }\r
 366           if (retrieved != null)\r
 367           {\r
 368             transferReferences(sdataset, dbSources[db], retrieved);\r
 369           }\r
 370         }\r
 371         else\r
 372         {\r
 373           // make some more strings for use as queries\r
 374           for (int i = 0; (seqIndex < dataset.length) && (i < 50); seqIndex++, i++)\r
 375           {\r
 376             SequenceI sequence = dataset[seqIndex];\r
 377             DBRefEntry[] uprefs = jalview.util.DBRefUtils.selectRefs(\r
 378                     sequence.getDBRef(), new String[]\r
 379                     { dbSources[db] }); // jalview.datamodel.DBRefSource.UNIPROT\r
 380             // });\r
 381             // check for existing dbrefs to use\r
 382             if (uprefs != null && uprefs.length > 0)\r
 383             {\r
 384               for (int j = 0; j < uprefs.length; j++)\r
 385               {\r
 386                 addSeqId(sequence, uprefs[j].getAccessionId());\r
 387                 queries\r
 388                         .addElement(uprefs[j].getAccessionId()\r
 389                                 .toUpperCase());\r
 390               }\r
 391             }\r
 392             else\r
 393             {\r
 394               // generate queries from sequence ID string\r
 395               StringTokenizer st = new StringTokenizer(sequence.getName(),\r
 396                       "|");\r
 397               while (st.hasMoreTokens())\r
 398               {\r
 399                 String token = st.nextToken();\r
 400                 UPEntry[] presp = null;\r
 401                 if (picrClient != null)\r
 402                 {\r
 403                   // resolve the string against PICR to recover valid IDs\r
 404                   try\r
 405                   {\r
 406                     presp = picrClient\r
 407                             .getUPIForAccession(token, null, picrClient\r
 408                                     .getMappedDatabaseNames(), null, true);\r
 409                   } catch (Exception e)\r
 410                   {\r
 411                     System.err.println("Exception with Picr for '" + token\r
 412                             + "'\n");\r
 413                     e.printStackTrace();\r
 414                   }\r
 415                 }\r
 416                 if (presp != null && presp.length > 0)\r
 417                 {\r
 418                   for (int id = 0; id < presp.length; id++)\r
 419                   {\r
 420                     // construct sequences from response if sequences are\r
 421                     // present, and do a transferReferences\r
 422                     // otherwise transfer non sequence x-references directly.\r
 423                   }\r
 424                   System.out\r
 425                           .println("Validated ID against PICR... (for what its worth):"\r
 426                                   + token);\r
 427                   addSeqId(sequence, token);\r
 428                   queries.addElement(token.toUpperCase());\r
 429                 }\r
 430                 else\r
 431                 {\r
 432                   // if ()\r
 433                   // System.out.println("Not querying source with token="+token+"\n");\r
 434                   addSeqId(sequence, token);\r
 435                   queries.addElement(token.toUpperCase());\r
 436                 }\r
 437               }\r
 438             }\r
 439           }\r
 440         }\r
 441       }\r
 442       // advance to next database\r
 443       db++;\r
 444     } // all databases have been queries.\r
 445     if (sbuffer.length() > 0)\r
 446     {\r
 447       output\r
 448               .setText("Your sequences have been verified against known sequence databases. Some of the ids have been\n"\r
 449                       + "altered, most likely the start/end residue will have been updated.\n"\r
 450                       + "Save your alignment to maintain the updated id.\n\n"\r
 451                       + sbuffer.toString());\r
 452       Desktop.addInternalFrame(output, "Sequence names updated ", 600, 300);\r
 453       // The above is the dataset, we must now find out the index\r
 454       // of the viewed sequence\r
 455 \r
 456     }\r
 457 \r
 458     af.setProgressBar("DBRef search completed", startTime);\r
 459     // promptBeforeBlast();\r
 460 \r
 461     running = false;\r
 462 \r
 463   }\r
 464 \r
 465   /**\r
 466    * Verify local sequences in seqRefs against the retrieved sequence database\r
 467    * records.\r
 468    * \r
 469    */\r
 470   void transferReferences(Vector sdataset, String dbSource,\r
 471           AlignmentI retrievedAl) // File\r
 472   // file)\r
 473   {\r
 474     if (retrievedAl == null || retrievedAl.getHeight() == 0)\r
 475     {\r
 476       return;\r
 477     }\r
 478     SequenceI[] retrieved = recoverDbSequences(retrievedAl\r
 479             .getSequencesArray());\r
 480     SequenceI sequence = null;\r
 481     boolean transferred = false;\r
 482     StringBuffer messages = new StringBuffer();\r
 483 \r
 484     // Vector entries = new Uniprot().getUniprotEntries(file);\r
 485 \r
 486     int i, iSize = retrieved.length; // entries == null ? 0 : entries.size();\r
 487     // UniprotEntry entry;\r
 488     for (i = 0; i < iSize; i++)\r
 489     {\r
 490       SequenceI entry = retrieved[i]; // (UniprotEntry) entries.elementAt(i);\r
 491 \r
 492       // Work out which sequences this sequence matches,\r
 493       // taking into account all accessionIds and names in the file\r
 494       Vector sequenceMatches = new Vector();\r
 495       // look for corresponding accession ids\r
 496       DBRefEntry[] entryRefs = jalview.util.DBRefUtils.selectRefs(entry\r
 497               .getDBRef(), new String[]\r
 498       { dbSource });\r
 499       for (int j = 0; j < entryRefs.length; j++)\r
 500       {\r
 501         String accessionId = entryRefs[j].getAccessionId(); // .getAccession().elementAt(j).toString();\r
 502         // match up on accessionId\r
 503         if (seqRefs.containsKey(accessionId.toUpperCase()))\r
 504         {\r
 505           Vector seqs = (Vector) seqRefs.get(accessionId);\r
 506           for (int jj = 0; jj < seqs.size(); jj++)\r
 507           {\r
 508             sequence = (SequenceI) seqs.elementAt(jj);\r
 509             if (!sequenceMatches.contains(sequence))\r
 510             {\r
 511               sequenceMatches.addElement(sequence);\r
 512             }\r
 513           }\r
 514         }\r
 515       }\r
 516       if (sequenceMatches.size() == 0)\r
 517       {\r
 518         // failed to match directly on accessionId==query so just compare all\r
 519         // sequences to entry\r
 520         Enumeration e = seqRefs.keys();\r
 521         while (e.hasMoreElements())\r
 522         {\r
 523           Vector sqs = (Vector) seqRefs.get(e.nextElement());\r
 524           if (sqs != null && sqs.size() > 0)\r
 525           {\r
 526             Enumeration sqe = sqs.elements();\r
 527             while (sqe.hasMoreElements())\r
 528             {\r
 529               sequenceMatches.addElement(sqe.nextElement());\r
 530             }\r
 531           }\r
 532         }\r
 533       }\r
 534       // look for corresponding names\r
 535       // this is uniprot specific ?\r
 536       // could be useful to extend this so we try to find any 'significant'\r
 537       // information in common between two sequence objects.\r
 538       /*\r
 539        * DBRefEntry[] entryRefs =\r
 540        * jalview.util.DBRefUtils.selectRefs(entry.getDBRef(), new String[] {\r
 541        * dbSource }); for (int j = 0; j < entry.getName().size(); j++) { String\r
 542        * name = entry.getName().elementAt(j).toString(); if\r
 543        * (seqRefs.containsKey(name)) { Vector seqs = (Vector) seqRefs.get(name);\r
 544        * for (int jj = 0; jj < seqs.size(); jj++) { sequence = (SequenceI)\r
 545        * seqs.elementAt(jj); if (!sequenceMatches.contains(sequence)) {\r
 546        * sequenceMatches.addElement(sequence); } } } }\r
 547        */\r
 548       // sequenceMatches now contains the set of all sequences associated with\r
 549       // the returned db record\r
 550       String entrySeq = entry.getSequenceAsString().toUpperCase();\r
 551       for (int m = 0; m < sequenceMatches.size(); m++)\r
 552       {\r
 553         sequence = (SequenceI) sequenceMatches.elementAt(m);\r
 554         // only update start and end positions and shift features if there are\r
 555         // no existing references\r
 556         // TODO: test for legacy where uniprot or EMBL refs exist but no\r
 557         // mappings are made (but content matches retrieved set)\r
 558         boolean updateRefFrame = sequence.getDBRef() == null\r
 559                 || sequence.getDBRef().length == 0;\r
 560         // verify sequence against the entry sequence\r
 561 \r
 562         String nonGapped = AlignSeq.extractGaps("-. ",\r
 563                 sequence.getSequenceAsString()).toUpperCase();\r
 564 \r
 565         int absStart = entrySeq.indexOf(nonGapped);\r
 566         int mapStart = entry.getStart();\r
 567         jalview.datamodel.Mapping mp;\r
 568 \r
 569         if (absStart == -1)\r
 570         {\r
 571           // Is local sequence contained in dataset sequence?\r
 572           absStart = nonGapped.indexOf(entrySeq);\r
 573           if (absStart == -1)\r
 574           { // verification failed.\r
 575             messages.append(sequence.getName()\r
 576                     + " SEQUENCE NOT %100 MATCH \n");\r
 577             continue;\r
 578           }\r
 579           transferred = true;\r
 580           sbuffer.append(sequence.getName() + " HAS " + absStart\r
 581                   + " PREFIXED RESIDUES COMPARED TO " + dbSource + "\n");\r
 582           //\r
 583           // + " - ANY SEQUENCE FEATURES"\r
 584           // + " HAVE BEEN ADJUSTED ACCORDINGLY \n");\r
 585           // absStart = 0;\r
 586           // create valid mapping between matching region of local sequence and\r
 587           // the mapped sequence\r
 588           mp = new Mapping(null, new int[]\r
 589           { sequence.getStart() + absStart,\r
 590               sequence.getStart() + absStart + entrySeq.length() - 1 },\r
 591                   new int[]\r
 592                   { entry.getStart(),\r
 593                       entry.getStart() + entrySeq.length() - 1 }, 1, 1);\r
 594           updateRefFrame = false; // mapping is based on current start/end so\r
 595           // don't modify start and end\r
 596         }\r
 597         else\r
 598         {\r
 599           transferred = true;\r
 600           // update start and end of local sequence to place it in entry's\r
 601           // reference frame.\r
 602           // apply identity map map from whole of local sequence to matching\r
 603           // region of database\r
 604           // sequence\r
 605           mp = null; // Mapping.getIdentityMap();\r
 606           // new Mapping(null,\r
 607           // new int[] { absStart+sequence.getStart(),\r
 608           // absStart+sequence.getStart()+entrySeq.length()-1},\r
 609           // new int[] { entry.getStart(), entry.getEnd() }, 1, 1);\r
 610           // relocate local features for updated start\r
 611           if (updateRefFrame && sequence.getSequenceFeatures() != null)\r
 612           {\r
 613             SequenceFeature[] sf = sequence.getSequenceFeatures();\r
 614             int start = sequence.getStart();\r
 615             int end = sequence.getEnd();\r
 616             int startShift = 1 - absStart - start; // how much the features are\r
 617             // to be shifted by\r
 618             for (int sfi = 0; sfi < sf.length; sfi++)\r
 619             {\r
 620               if (sf[sfi].getBegin() >= start && sf[sfi].getEnd() <= end)\r
 621               {\r
 622                 // shift feature along by absstart\r
 623                 sf[sfi].setBegin(sf[sfi].getBegin() + startShift);\r
 624                 sf[sfi].setEnd(sf[sfi].getEnd() + startShift);\r
 625               }\r
 626             }\r
 627           }\r
 628         }\r
 629 \r
 630         System.out.println("Adding dbrefs to " + sequence.getName()\r
 631                 + " from " + dbSource + " sequence : " + entry.getName());\r
 632         sequence.transferAnnotation(entry, mp);\r
 633         // unknownSequences.remove(sequence);\r
 634         int absEnd = absStart + nonGapped.length();\r
 635         absStart += 1;\r
 636         if (updateRefFrame)\r
 637         {\r
 638           // finally, update local sequence reference frame if we're allowed\r
 639           sequence.setStart(absStart);\r
 640           sequence.setEnd(absEnd);\r
 641         }\r
 642         // and remove it from the rest\r
 643         // TODO: decide if we should remove annotated sequence from set\r
 644         sdataset.remove(sequence);\r
 645         // TODO: should we make a note of sequences that have received new DB\r
 646         // ids, so we can query all enabled DAS servers for them ?\r
 647       }\r
 648     }\r
 649     if (!transferred)\r
 650     {\r
 651       // report the ID/sequence mismatches\r
 652       sbuffer.append(messages);\r
 653     }\r
 654   }\r
 655 \r
 656   /**\r
 657    * loop thru and collect additional sequences in Map.\r
 658    * \r
 659    * @param sequencesArray\r
 660    * @return\r
 661    */\r
 662   private SequenceI[] recoverDbSequences(SequenceI[] sequencesArray)\r
 663   {\r
 664     Vector nseq = new Vector();\r
 665     for (int i = 0; sequencesArray != null && i < sequencesArray.length; i++)\r
 666     {\r
 667       nseq.addElement(sequencesArray[i]);\r
 668       DBRefEntry dbr[] = sequencesArray[i].getDBRef();\r
 669       jalview.datamodel.Mapping map = null;\r
 670       for (int r = 0; (dbr != null) && r < dbr.length; r++)\r
 671       {\r
 672         if ((map = dbr[r].getMap()) != null)\r
 673         {\r
 674           if (map.getTo() != null && !nseq.contains(map.getTo()))\r
 675           {\r
 676             nseq.addElement(map.getTo());\r
 677           }\r
 678         }\r
 679       }\r
 680     }\r
 681     if (nseq.size() > 0)\r
 682     {\r
 683       sequencesArray = new SequenceI[nseq.size()];\r
 684       nseq.toArray(sequencesArray);\r
 685     }\r
 686     return sequencesArray;\r
 687   }\r
 688 }\r