src/jalview/ws/DasSequenceFeatureFetcher.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1)
   3  * Copyright (C) 2014 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.bin.Cache;
  24 import jalview.datamodel.DBRefEntry;
  25 import jalview.datamodel.SequenceFeature;
  26 import jalview.datamodel.SequenceI;
  27 import jalview.gui.AlignFrame;
  28 import jalview.gui.Desktop;
  29 import jalview.gui.FeatureSettings;
  30 import jalview.util.MessageManager;
  31 import jalview.util.UrlLink;
  32 import jalview.ws.dbsources.das.api.DasSourceRegistryI;
  33 import jalview.ws.dbsources.das.api.jalviewSourceI;
  34
  35 import java.util.ArrayList;
  36 import java.util.Arrays;
  37 import java.util.Enumeration;
  38 import java.util.HashMap;
  39 import java.util.HashSet;
  40 import java.util.Iterator;
  41 import java.util.List;
  42 import java.util.Map;
  43 import java.util.Set;
  44 import java.util.StringTokenizer;
  45 import java.util.Vector;
  46
  47 import javax.swing.JOptionPane;
  48
  49 import org.biodas.jdas.client.FeaturesClient;
  50 import org.biodas.jdas.client.adapters.features.DasGFFAdapter;
  51 import org.biodas.jdas.client.adapters.features.DasGFFAdapter.GFFAdapter;
  52 import org.biodas.jdas.client.threads.FeaturesClientMultipleSources;
  53 import org.biodas.jdas.schema.features.ERRORSEGMENT;
  54 import org.biodas.jdas.schema.features.FEATURE;
  55 import org.biodas.jdas.schema.features.LINK;
  56 import org.biodas.jdas.schema.features.SEGMENT;
  57 import org.biodas.jdas.schema.features.TYPE;
  58 import org.biodas.jdas.schema.features.UNKNOWNFEATURE;
  59 import org.biodas.jdas.schema.features.UNKNOWNSEGMENT;
  60 import org.biodas.jdas.schema.sources.COORDINATES;
  61
  62 /**
  63  * DOCUMENT ME!
  64  *
  65  * @author $author$
  66  * @version $Revision$
  67  */
  68 public class DasSequenceFeatureFetcher
  69 {
  70   SequenceI[] sequences;
  71
  72   AlignFrame af;
  73
  74   FeatureSettings fsettings;
  75
  76   StringBuffer sbuffer = new StringBuffer();
  77
  78   List<jalviewSourceI> selectedSources;
  79
  80   boolean cancelled = false;
  81
  82   private void debug(String mesg)
  83   {
  84     debug(mesg, null);
  85   }
  86
  87   private void debug(String mesg, Exception e)
  88   {
  89     if (Cache.log != null)
  90     {
  91       Cache.log.debug(mesg, e);
  92     }
  93     else
  94     {
  95       System.err.println(mesg);
  96       if (e != null)
  97       {
  98         e.printStackTrace();
  99       }
 100     }
 101   }
 102
 103   long startTime;
 104
 105   private DasSourceRegistryI sourceRegistry;
 106
 107   private boolean useJDASMultiThread = true;
 108
 109   /**
 110    * Creates a new SequenceFeatureFetcher object. Uses default
 111    *
 112    * @param align
 113    *          DOCUMENT ME!
 114    * @param ap
 115    *          DOCUMENT ME!
 116    */
 117   public DasSequenceFeatureFetcher(SequenceI[] sequences,
 118           FeatureSettings fsettings, Vector selectedSources)
 119   {
 120     this(sequences, fsettings, selectedSources, true, true, true);
 121   }
 122
 123   public DasSequenceFeatureFetcher(SequenceI[] oursequences,
 124           FeatureSettings fsettings, List<jalviewSourceI> selectedSources2,
 125           boolean checkDbrefs, boolean promptFetchDbrefs)
 126   {
 127     this(oursequences, fsettings, selectedSources2, checkDbrefs,
 128             promptFetchDbrefs, true);
 129   }
 130
 131   public DasSequenceFeatureFetcher(SequenceI[] oursequences,
 132           FeatureSettings fsettings, List<jalviewSourceI> selectedSources2,
 133           boolean checkDbrefs, boolean promptFetchDbrefs,
 134           boolean useJDasMultiThread)
 135   {
 136     this.useJDASMultiThread = useJDasMultiThread;
 137     this.selectedSources = new ArrayList<jalviewSourceI>();
 138     // filter both sequences and sources to eliminate duplicates
 139     for (jalviewSourceI src : selectedSources2)
 140     {
 141       if (!selectedSources.contains(src))
 142       {
 143         selectedSources.add(src);
 144       }
 145       ;
 146     }
 147     Vector sqs = new Vector();
 148     for (int i = 0; i < oursequences.length; i++)
 149     {
 150       if (!sqs.contains(oursequences[i]))
 151       {
 152         sqs.addElement(oursequences[i]);
 153       }
 154     }
 155     sequences = new SequenceI[sqs.size()];
 156     for (int i = 0; i < sequences.length; i++)
 157     {
 158       sequences[i] = (SequenceI) sqs.elementAt(i);
 159     }
 160     if (fsettings != null)
 161     {
 162       this.fsettings = fsettings;
 163       this.af = fsettings.af;
 164       af.setShowSeqFeatures(true);
 165     }
 166     int uniprotCount = 0;
 167     for (jalviewSourceI source : selectedSources)
 168     {
 169       for (COORDINATES coords : source.getVersion().getCOORDINATES())
 170       {
 171         // TODO: match UniProt coord system canonically (?) - does
 172         // UniProt==uniprot==UNIPROT ?
 173         if (coords.getAuthority().toLowerCase().equals("uniprot"))
 174         {
 175           uniprotCount++;
 176           break;
 177         }
 178       }
 179     }
 180
 181     int refCount = 0;
 182     for (int i = 0; i < sequences.length; i++)
 183     {
 184       DBRefEntry[] dbref = sequences[i].getDBRef();
 185       if (dbref != null)
 186       {
 187         for (int j = 0; j < dbref.length; j++)
 188         {
 189           if (dbref[j].getSource().equals(
 190                   jalview.datamodel.DBRefSource.UNIPROT))
 191           {
 192             refCount++;
 193             break;
 194           }
 195         }
 196       }
 197     }
 198
 199     if (checkDbrefs && refCount < sequences.length && uniprotCount > 0)
 200     {
 201
 202       int reply = JOptionPane.YES_OPTION;
 203       if (promptFetchDbrefs)
 204       {
 205         reply = JOptionPane
 206                 .showInternalConfirmDialog(
 207                         Desktop.desktop,
 208                         MessageManager.getString("info.you_want_jalview_to_find_uniprot_accessions"),
 209                         MessageManager.getString("label.find_uniprot_accession_ids"),
 210                         JOptionPane.YES_NO_OPTION,
 211                         JOptionPane.QUESTION_MESSAGE);
 212       }
 213
 214       if (reply == JOptionPane.YES_OPTION)
 215       {
 216         Thread thread = new Thread(new FetchDBRefs());
 217         thread.start();
 218       }
 219       else
 220       {
 221         _startFetching();
 222       }
 223     }
 224     else
 225     {
 226       _startFetching();
 227     }
 228
 229   }
 230
 231   private void _startFetching()
 232   {
 233     running = true;
 234     new Thread(new FetchSeqFeatures()).start();
 235   }
 236
 237   class FetchSeqFeatures implements Runnable
 238   {
 239     public void run()
 240     {
 241       startFetching();
 242       setGuiFetchComplete();
 243     }
 244   }
 245
 246   class FetchDBRefs implements Runnable
 247   {
 248     public void run()
 249     {
 250       running = true;
 251       new DBRefFetcher(sequences, af).fetchDBRefs(true);
 252       startFetching();
 253       setGuiFetchComplete();
 254     }
 255   }
 256
 257   /**
 258    * Spawns Fetcher threads to add features to sequences in the dataset
 259    */
 260   void startFetching()
 261   {
 262     running = true;
 263     cancelled = false;
 264     startTime = System.currentTimeMillis();
 265     if (af != null)
 266     {
 267       af.setProgressBar(MessageManager.getString("status.fetching_das_sequence_features"), startTime);
 268     }
 269     if (sourceRegistry == null)
 270     {
 271       sourceRegistry = Cache.getDasSourceRegistry();
 272     }
 273     if (selectedSources == null || selectedSources.size() == 0)
 274     {
 275       try
 276       {
 277         jalviewSourceI[] sources = sourceRegistry.getSources().toArray(
 278                 new jalviewSourceI[0]);
 279         String active = jalview.bin.Cache.getDefault("DAS_ACTIVE_SOURCE",
 280                 "uniprot");
 281         StringTokenizer st = new StringTokenizer(active, "\t");
 282         selectedSources = new Vector();
 283         String token;
 284         while (st.hasMoreTokens())
 285         {
 286           token = st.nextToken();
 287           for (int i = 0; i < sources.length; i++)
 288           {
 289             if (sources[i].getTitle().equals(token))
 290             {
 291               selectedSources.add(sources[i]);
 292               break;
 293             }
 294           }
 295         }
 296       } catch (Exception ex)
 297       {
 298         debug("Exception whilst setting default feature sources from registry and local preferences.",
 299                 ex);
 300       }
 301     }
 302
 303     if (selectedSources == null || selectedSources.size() == 0)
 304     {
 305       System.out.println("No DAS Sources active");
 306       cancelled = true;
 307       setGuiNoDassourceActive();
 308       return;
 309     }
 310
 311     sourcesRemaining = selectedSources.size();
 312     FeaturesClientMultipleSources fc = new FeaturesClientMultipleSources();
 313     fc.setConnProps(sourceRegistry.getSessionHandler());
 314     // Now sending requests one at a time to each server
 315     ArrayList<jalviewSourceI> srcobj = new ArrayList<jalviewSourceI>();
 316     ArrayList<String> src = new ArrayList<String>();
 317     List<List<String>> ids = new ArrayList<List<String>>();
 318     List<List<DBRefEntry>> idobj = new ArrayList<List<DBRefEntry>>();
 319     List<Map<String, SequenceI>> sqset = new ArrayList<Map<String, SequenceI>>();
 320     for (jalviewSourceI _sr : selectedSources)
 321     {
 322
 323       Map<String, SequenceI> slist = new HashMap<String, SequenceI>();
 324       List<DBRefEntry> idob = new ArrayList<DBRefEntry>();
 325       List<String> qset = new ArrayList<String>();
 326
 327       for (SequenceI seq : sequences)
 328       {
 329         Object[] idset = nextSequence(_sr, seq);
 330         if (idset != null)
 331         {
 332           List<DBRefEntry> _idob = (List<DBRefEntry>) idset[0];
 333           List<String> _qset = (List<String>) idset[1];
 334           if (_idob.size() > 0)
 335           {
 336             // add sequence's ref for each id derived from it
 337             // (space inefficient, but most unambiguous)
 338             // could replace with hash with _qset values as keys.
 339             Iterator<DBRefEntry> dbobj = _idob.iterator();
 340             for (String q : _qset)
 341             {
 342               SequenceI osq = slist.get(q);
 343               DBRefEntry dr = dbobj.next();
 344               if (osq != null && osq != seq)
 345               {
 346                 // skip - non-canonical query
 347               }
 348               else
 349               {
 350                 idob.add(dr);
 351                 qset.add(q);
 352                 slist.put(q, seq);
 353               }
 354             }
 355           }
 356         }
 357       }
 358       if (idob.size() > 0)
 359       {
 360         srcobj.add(_sr);
 361         src.add(_sr.getSourceURL());
 362         ids.add(qset);
 363         idobj.add(idob);
 364         sqset.add(slist);
 365       }
 366     }
 367     Map<String, Map<List<String>, Exception>> errors = new HashMap<String, Map<List<String>, Exception>>();
 368     Map<String, Map<List<String>, DasGFFAdapter>> results = new HashMap<String, Map<List<String>, DasGFFAdapter>>();
 369     if (!useJDASMultiThread)
 370     {
 371       Iterator<String> sources = src.iterator();
 372       // iterate over each query for each source and do each one individually
 373       for (List<String> idl : ids)
 374       {
 375         String source = sources.next();
 376         FeaturesClient featuresc = new FeaturesClient(sourceRegistry
 377                 .getSessionHandler().getConnectionPropertyProviderFor(
 378                         source));
 379         for (String id : idl)
 380         {
 381           List<String> qid = Arrays.asList(new String[]
 382           { id });
 383           try
 384           {
 385             DasGFFAdapter dga = featuresc.fetchData(source, qid);
 386             Map<List<String>, DasGFFAdapter> ers = results.get(source);
 387             if (ers == null)
 388             {
 389               results.put(source,
 390                       ers = new HashMap<List<String>, DasGFFAdapter>());
 391             }
 392             ers.put(qid, dga);
 393           } catch (Exception ex)
 394           {
 395             Map<List<String>, Exception> ers = errors.get(source);
 396             if (ers == null)
 397             {
 398               errors.put(source,
 399                       ers = new HashMap<List<String>, Exception>());
 400             }
 401             ers.put(qid, ex);
 402           }
 403         }
 404       }
 405     }
 406     else
 407     {
 408       // pass them all at once
 409       fc.fetchData(src, ids, false, results, errors);
 410       fc.shutDown();
 411       while (!fc.isTerminated())
 412       {
 413         try
 414         {
 415           Thread.sleep(200);
 416         } catch (InterruptedException x)
 417         {
 418
 419         }
 420       }
 421     }
 422     Iterator<List<String>> idset = ids.iterator();
 423     Iterator<List<DBRefEntry>> idobjset = idobj.iterator();
 424     Iterator<Map<String, SequenceI>> seqset = sqset.iterator();
 425     for (jalviewSourceI source : srcobj)
 426     {
 427       processResponse(seqset.next(), source, idset.next(), idobjset.next(),
 428               results.get(source.getSourceURL()),
 429               errors.get(source.getSourceURL()));
 430     }
 431   }
 432
 433   private void processResponse(Map<String, SequenceI> sequencemap,
 434           jalviewSourceI jvsource, List<String> ids,
 435           List<DBRefEntry> idobj, Map<List<String>, DasGFFAdapter> results,
 436           Map<List<String>, Exception> errors)
 437   {
 438     Set<SequenceI> sequences = new HashSet<SequenceI>();
 439     String source = jvsource.getSourceURL();
 440     // process features
 441     DasGFFAdapter result = (results == null) ? null : results.get(ids);
 442     Exception error = (errors == null) ? null : errors.get(ids);
 443     if (result == null)
 444     {
 445       debug("das source " + source + " could not be contacted. "
 446               + (error == null ? "" : error.toString()));
 447     }
 448     else
 449     {
 450
 451       GFFAdapter gff = result.getGFF();
 452       List<SEGMENT> segments = gff.getSegments();
 453       List<ERRORSEGMENT> errorsegs = gff.getErrorSegments();
 454       List<UNKNOWNFEATURE> unkfeats = gff.getUnknownFeatures();
 455       List<UNKNOWNSEGMENT> unksegs = gff.getUnknownSegments();
 456       debug("das source " + source + " returned " + gff.getTotal()
 457               + " responses. " + (errorsegs != null ? errorsegs.size() : 0)
 458               + " were incorrect segment queries, "
 459               + (unkfeats != null ? unkfeats.size() : 0)
 460               + " were unknown features "
 461               + (unksegs != null ? unksegs.size() : 0)
 462               + " were unknown segments and "
 463               + (segments != null ? segments.size() : 0)
 464               + " were segment responses.");
 465       Iterator<DBRefEntry> dbr = idobj.iterator();
 466       if (segments != null)
 467       {
 468         for (SEGMENT seg : segments)
 469         {
 470           String id = seg.getId();
 471           if (ids.indexOf(id) == -1)
 472           {
 473             id = id.toUpperCase();
 474           }
 475           DBRefEntry dbref = idobj.get(ids.indexOf(id));
 476           SequenceI sequence = sequencemap.get(id);
 477           boolean added = false;
 478           sequences.add(sequence);
 479
 480           for (FEATURE feat : seg.getFEATURE())
 481           {
 482             // standard DAS feature-> jalview sequence feature transformation
 483             SequenceFeature f = newSequenceFeature(feat,
 484                     jvsource.getTitle());
 485             if (!parseSeqFeature(sequence, f, feat, jvsource))
 486             {
 487               if (dbref.getMap() != null && f.getBegin() > 0
 488                       && f.getEnd() > 0)
 489               {
 490                 debug("mapping from " + f.getBegin() + " - " + f.getEnd());
 491                 SequenceFeature vf[] = null;
 492
 493                 try
 494                 {
 495                   vf = dbref.getMap().locateFeature(f);
 496                 } catch (Exception ex)
 497                 {
 498                   Cache.log
 499                           .warn("Error in 'experimental' mapping of features. Please try to reproduce and then report info to jalview-discuss@jalview.org.");
 500                   Cache.log.warn("Mapping feature from " + f.getBegin()
 501                           + " to " + f.getEnd() + " in dbref "
 502                           + dbref.getAccessionId() + " in "
 503                           + dbref.getSource());
 504                   Cache.log.warn("using das Source " + source);
 505                   Cache.log.warn("Exception", ex);
 506                 }
 507
 508                 if (vf != null)
 509                 {
 510                   for (int v = 0; v < vf.length; v++)
 511                   {
 512                     debug("mapping to " + v + ": " + vf[v].getBegin()
 513                             + " - " + vf[v].getEnd());
 514                     sequence.addSequenceFeature(vf[v]);
 515                   }
 516                 }
 517               }
 518               else
 519               {
 520                 sequence.addSequenceFeature(f);
 521               }
 522             }
 523           }
 524         }
 525         featuresAdded(sequences);
 526       }
 527       else
 528       {
 529         // System.out.println("No features found for " + seq.getName()
 530         // + " from: " + e.getDasSource().getNickname());
 531       }
 532     }
 533   }
 534
 535   private void setGuiNoDassourceActive()
 536   {
 537
 538     if (af != null)
 539     {
 540       af.setProgressBar(MessageManager.getString("status.no_das_sources_active"), startTime);
 541     }
 542     if (getFeatSettings() != null)
 543     {
 544       fsettings.noDasSourceActive();
 545     }
 546   }
 547
 548   /**
 549    * Update our fsettings dialog reference if we didn't have one when we were
 550    * first initialised.
 551    *
 552    * @return fsettings
 553    */
 554   private FeatureSettings getFeatSettings()
 555   {
 556     if (fsettings == null)
 557     {
 558       if (af != null)
 559       {
 560         fsettings = af.featureSettings;
 561       }
 562     }
 563     return fsettings;
 564   }
 565
 566   public void cancel()
 567   {
 568     if (af != null)
 569     {
 570       af.setProgressBar(MessageManager.getString("status.das_feature_fetching_cancelled"), startTime);
 571     }
 572     cancelled = true;
 573   }
 574
 575   int sourcesRemaining = 0;
 576
 577   private boolean running = false;
 578
 579   private void setGuiFetchComplete()
 580   {
 581     running = false;
 582     if (!cancelled && af != null)
 583     {
 584       // only update the progress bar if we've completed the fetch normally
 585       af.setProgressBar(MessageManager.getString("status.das_feature_fetching_complete"), startTime);
 586     }
 587
 588     if (af != null && af.featureSettings != null)
 589     {
 590       af.featureSettings.setTableData();
 591     }
 592
 593     if (getFeatSettings() != null)
 594     {
 595       fsettings.complete();
 596     }
 597   }
 598
 599   void featuresAdded(Set<SequenceI> seqs)
 600   {
 601     if (af == null)
 602     {
 603       // no gui to update with features.
 604       return;
 605     }
 606     af.getFeatureRenderer().featuresAdded();
 607
 608     int start = af.getViewport().getStartSeq();
 609     int end = af.getViewport().getEndSeq();
 610     int index;
 611     for (index = start; index < end; index++)
 612     {
 613       for (SequenceI seq : seqs)
 614       {
 615         if (seq == af.getViewport().getAlignment().getSequenceAt(index)
 616                 .getDatasetSequence())
 617         {
 618           af.alignPanel.paintAlignment(true);
 619           index = end;
 620           break;
 621         }
 622       }
 623     }
 624   }
 625
 626   Object[] nextSequence(jalviewSourceI dasSource, SequenceI seq)
 627   {
 628     if (cancelled)
 629     {
 630       return null;
 631     }
 632     DBRefEntry[] uprefs = jalview.util.DBRefUtils.selectRefs(
 633             seq.getDBRef(), new String[]
 634             {
 635             // jalview.datamodel.DBRefSource.PDB,
 636             jalview.datamodel.DBRefSource.UNIPROT,
 637             // jalview.datamodel.DBRefSource.EMBL - not tested on any EMBL coord
 638             // sys sources
 639             });
 640     // TODO: minimal list of DAS queries to make by querying with untyped ID if
 641     // distinct from any typed IDs
 642
 643     List<DBRefEntry> ids = new ArrayList<DBRefEntry>();
 644     List<String> qstring = new ArrayList<String>();
 645     boolean dasCoordSysFound = false;
 646
 647     if (uprefs != null)
 648     {
 649       // do any of these ids match the source's coordinate system ?
 650       for (int j = 0; !dasCoordSysFound && j < uprefs.length; j++)
 651       {
 652
 653         for (COORDINATES csys : dasSource.getVersion().getCOORDINATES())
 654         {
 655           if (jalview.util.DBRefUtils.isDasCoordinateSystem(
 656                   csys.getAuthority(), uprefs[j]))
 657           {
 658             debug("Launched fetcher for coordinate system "
 659                     + csys.getAuthority());
 660             // Will have to pass any mapping information to the fetcher
 661             // - the start/end for the DBRefEntry may not be the same as the
 662             // sequence's start/end
 663
 664             System.out.println(seq.getName() + " "
 665                     + (seq.getDatasetSequence() == null) + " "
 666                     + csys.getUri());
 667
 668             dasCoordSysFound = true; // break's out of the loop
 669             ids.add(uprefs[j]);
 670             qstring.add(uprefs[j].getAccessionId());
 671           }
 672           else
 673           {
 674             System.out.println("IGNORE " + csys.getAuthority());
 675           }
 676         }
 677       }
 678     }
 679
 680     if (!dasCoordSysFound)
 681     {
 682       String id = null;
 683       // try and use the name as the sequence id
 684       if (seq.getName().indexOf("|") > -1)
 685       {
 686         id = seq.getName().substring(seq.getName().lastIndexOf("|") + 1);
 687         if (id.trim().length() < 4)
 688         {
 689           // hack - we regard a significant ID as being at least 4
 690           // non-whitespace characters
 691           id = seq.getName().substring(0, seq.getName().lastIndexOf("|"));
 692           if (id.indexOf("|") > -1)
 693           {
 694             id = id.substring(id.lastIndexOf("|") + 1);
 695           }
 696         }
 697       }
 698       else
 699       {
 700         id = seq.getName();
 701       }
 702       if (id != null)
 703       {
 704         DBRefEntry dbre = new DBRefEntry();
 705         dbre.setAccessionId(id);
 706         // Should try to call a general feature fetcher that
 707         // queries many sources with name to discover applicable ID references
 708         ids.add(dbre);
 709         qstring.add(dbre.getAccessionId());
 710       }
 711     }
 712
 713     return new Object[]
 714     { ids, qstring };
 715   }
 716
 717   /**
 718    * examine the given sequence feature to determine if it should actually be
 719    * turned into sequence annotation or database cross references rather than a
 720    * simple sequence feature.
 721    *
 722    * @param seq
 723    *          the sequence to annotate
 724    * @param f
 725    *          the jalview sequence feature generated from the DAS feature
 726    * @param map
 727    *          the sequence feature attributes
 728    * @param source
 729    *          the source that emitted the feature
 730    * @return true if feature was consumed as another kind of annotation.
 731    */
 732   protected boolean parseSeqFeature(SequenceI seq, SequenceFeature f,
 733           FEATURE feature, jalviewSourceI source)
 734   {
 735     SequenceI mseq = seq;
 736     while (seq.getDatasetSequence() != null)
 737     {
 738       seq = seq.getDatasetSequence();
 739     }
 740     if (f.getType() != null)
 741     {
 742       String type = f.getType();
 743       if (type.equalsIgnoreCase("protein_name"))
 744       {
 745         // parse name onto the alignment sequence or the dataset sequence.
 746         if (seq.getDescription() == null
 747                 || seq.getDescription().trim().length() == 0)
 748         {
 749           // could look at the note series to pick out the first long name, for
 750           // the moment just use the whole description string
 751           seq.setDescription(f.getDescription());
 752         }
 753         if (mseq.getDescription() == null
 754                 || mseq.getDescription().trim().length() == 0)
 755         {
 756           // could look at the note series to pick out the first long name, for
 757           // the moment just use the whole description string
 758           mseq.setDescription(f.getDescription());
 759         }
 760         return true;
 761       }
 762       // check if source has biosapiens or other sequence ontology label
 763       if (type.equalsIgnoreCase("DBXREF") || type.equalsIgnoreCase("DBREF"))
 764       {
 765         // try to parse the accession out
 766
 767         DBRefEntry dbr = new DBRefEntry();
 768         dbr.setVersion(source.getTitle());
 769         StringTokenizer st = new StringTokenizer(f.getDescription(), ":");
 770         if (st.hasMoreTokens())
 771         {
 772           dbr.setSource(st.nextToken());
 773         }
 774         if (st.hasMoreTokens())
 775         {
 776           dbr.setAccessionId(st.nextToken());
 777         }
 778         seq.addDBRef(dbr);
 779
 780         if (f.links != null && f.links.size() > 0)
 781         {
 782           // feature is also appended to enable links to be seen.
 783           // TODO: consider extending dbrefs to have their own links ?
 784           // TODO: new feature: extract dbref links from DAS servers and add the
 785           // URL pattern to the list of DB name associated links in the user's
 786           // preferences ?
 787           // for the moment - just fix up the existing feature so it displays
 788           // correctly.
 789           // f.setType(dbr.getSource());
 790           // f.setDescription();
 791           f.setValue("linkonly", Boolean.TRUE);
 792           // f.setDescription("");
 793           Vector newlinks = new Vector();
 794           Enumeration it = f.links.elements();
 795           while (it.hasMoreElements())
 796           {
 797             String elm;
 798             UrlLink urllink = new UrlLink(elm = (String) it.nextElement());
 799             if (urllink.isValid())
 800             {
 801               urllink.setLabel(f.getDescription());
 802               newlinks.addElement(urllink.toString());
 803             }
 804             else
 805             {
 806               // couldn't parse the link properly. Keep it anyway - just in
 807               // case.
 808               debug("couldn't parse link string - " + elm);
 809               newlinks.addElement(elm);
 810             }
 811           }
 812           f.links = newlinks;
 813           seq.addSequenceFeature(f);
 814         }
 815         return true;
 816       }
 817     }
 818     return false;
 819   }
 820
 821   /**
 822    * creates a jalview sequence feature from a das feature document
 823    *
 824    * @param feat
 825    * @return sequence feature object created using dasfeature information
 826    */
 827   SequenceFeature newSequenceFeature(FEATURE feat, String nickname)
 828   {
 829     if (feat == null)
 830     {
 831       return null;
 832     }
 833     try
 834     {
 835       /**
 836        * Different qNames for a DAS Feature - are string keys to the HashMaps in
 837        * features "METHOD") || qName.equals("TYPE") || qName.equals("START") ||
 838        * qName.equals("END") || qName.equals("NOTE") || qName.equals("LINK") ||
 839        * qName.equals("SCORE")
 840        */
 841       String desc = new String();
 842       if (feat.getNOTE() != null)
 843       {
 844         for (String note : feat.getNOTE())
 845         {
 846           desc += note;
 847         }
 848       }
 849
 850       int start = 0, end = 0;
 851       float score = 0f;
 852
 853       try
 854       {
 855         start = Integer.parseInt(feat.getSTART().toString());
 856       } catch (Exception ex)
 857       {
 858       }
 859       try
 860       {
 861         end = Integer.parseInt(feat.getEND().toString());
 862       } catch (Exception ex)
 863       {
 864       }
 865       try
 866       {
 867         Object scr = feat.getSCORE();
 868         if (scr != null)
 869         {
 870           score = (float) Double.parseDouble(scr.toString());
 871
 872         }
 873       } catch (Exception ex)
 874       {
 875       }
 876
 877       SequenceFeature f = new SequenceFeature(
 878               getTypeString(feat.getTYPE()), desc, start, end, score,
 879               nickname);
 880
 881       if (feat.getLINK() != null)
 882       {
 883         for (LINK link : feat.getLINK())
 884         {
 885           // Do not put feature extent in link text for non-positional features
 886           if (f.begin == 0 && f.end == 0)
 887           {
 888             f.addLink(f.getType() + " " + link.getContent() + "|"
 889                     + link.getHref());
 890           }
 891           else
 892           {
 893             f.addLink(f.getType() + " " + f.begin + "_" + f.end + " "
 894                     + link.getContent() + "|" + link.getHref());
 895           }
 896         }
 897       }
 898
 899       return f;
 900     } catch (Exception e)
 901     {
 902       System.out.println("ERRR " + e);
 903       e.printStackTrace();
 904       System.out.println("############");
 905       debug("Failed to parse " + feat.toString(), e);
 906       return null;
 907     }
 908   }
 909
 910   private String getTypeString(TYPE type)
 911   {
 912     return type.getContent();
 913   }
 914
 915   public boolean isRunning()
 916   {
 917     return running;
 918   }
 919
 920 }