src/jalview/ws/seqfetcher/ASequenceFetcher.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.seqfetcher;
  22
  23 import jalview.api.FeatureSettingsModelI;
  24 import jalview.bin.Cache;
  25 import jalview.datamodel.AlignmentI;
  26 import jalview.datamodel.DBRefEntry;
  27 import jalview.datamodel.SequenceI;
  28 import jalview.util.DBRefUtils;
  29 import jalview.util.MessageManager;
  30
  31 import java.util.ArrayList;
  32 import java.util.Collections;
  33 import java.util.Comparator;
  34 import java.util.Enumeration;
  35 import java.util.HashSet;
  36 import java.util.Hashtable;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Stack;
  40 import java.util.Vector;
  41
  42 public class ASequenceFetcher
  43 {
  44
  45   /*
  46    * set of databases we can retrieve entries from
  47    */
  48   protected Hashtable<String, Map<String, DbSourceProxy>> fetchableDbs;
  49
  50   /*
  51    * comparator to sort by tier (0/1/2) and name
  52    */
  53   private Comparator<DbSourceProxy> proxyComparator;
  54
  55   /**
  56    * Constructor
  57    */
  58   public ASequenceFetcher()
  59   {
  60     super();
  61
  62     /*
  63      * comparator to sort proxies by tier and name
  64      */
  65     proxyComparator = new Comparator<DbSourceProxy>()
  66     {
  67       @Override
  68       public int compare(DbSourceProxy o1, DbSourceProxy o2)
  69       {
  70         /*
  71          * Tier 0 precedes 1 precedes 2
  72          */
  73         int compared = Integer.compare(o1.getTier(), o2.getTier());
  74         if (compared == 0)
  75         {
  76           // defend against NullPointer - should never happen
  77           String o1Name = o1.getDbName();
  78           String o2Name = o2.getDbName();
  79           if (o1Name != null && o2Name != null)
  80           {
  81             compared = o1Name.compareToIgnoreCase(o2Name);
  82           }
  83         }
  84         return compared;
  85       }
  86     };
  87   }
  88
  89   /**
  90    * get array of supported Databases
  91    *
  92    * @return database source string for each database - only the latest version
  93    *         of a source db is bound to each source.
  94    */
  95   public String[] getSupportedDb()
  96   {
  97     if (fetchableDbs == null)
  98     {
  99       return null;
 100     }
 101     String[] sf = fetchableDbs.keySet().toArray(
 102             new String[fetchableDbs.size()]);
 103     return sf;
 104   }
 105
 106   public boolean isFetchable(String source)
 107   {
 108     for (String db : fetchableDbs.keySet())
 109     {
 110       if (source.equalsIgnoreCase(db))
 111       {
 112         return true;
 113       }
 114     }
 115     Cache.log.warn("isFetchable doesn't know about '" + source
 116             + "'");
 117     return false;
 118   }
 119
 120   /**
 121    * Fetch sequences for the given cross-references
 122    *
 123    * @param refs
 124    * @param dna
 125    *          if true, only fetch from nucleotide data sources, else peptide
 126    * @return
 127    */
 128   public SequenceI[] getSequences(DBRefEntry[] refs, boolean dna)
 129   {
 130     Vector<SequenceI> rseqs = new Vector<SequenceI>();
 131     Hashtable<String, List<String>> queries = new Hashtable<String, List<String>>();
 132     for (int r = 0; r < refs.length; r++)
 133     {
 134       if (!queries.containsKey(refs[r].getSource()))
 135       {
 136         queries.put(refs[r].getSource(), new ArrayList<String>());
 137       }
 138       List<String> qset = queries.get(refs[r].getSource());
 139       if (!qset.contains(refs[r].getAccessionId()))
 140       {
 141         qset.add(refs[r].getAccessionId());
 142       }
 143     }
 144     Enumeration<String> e = queries.keys();
 145     while (e.hasMoreElements())
 146     {
 147       List<String> query = null;
 148       String db = null;
 149       db = e.nextElement();
 150       query = queries.get(db);
 151       if (!isFetchable(db))
 152       {
 153         reportStdError(db, query, new Exception(
 154                 "Don't know how to fetch from this database :" + db));
 155         continue;
 156       }
 157
 158       Stack<String> queriesLeft = new Stack<String>();
 159       queriesLeft.addAll(query);
 160
 161       List<DbSourceProxy> proxies = getSourceProxy(db);
 162       for (DbSourceProxy fetcher : proxies)
 163       {
 164         List<String> queriesMade = new ArrayList<String>();
 165         HashSet<String> queriesFound = new HashSet<String>();
 166         try
 167         {
 168           if (fetcher.isDnaCoding() != dna)
 169           {
 170             continue; // wrong sort of data
 171           }
 172           boolean doMultiple = fetcher.getMaximumQueryCount() > 1;
 173           while (!queriesLeft.isEmpty())
 174           {
 175             StringBuffer qsb = new StringBuffer();
 176             do
 177             {
 178               if (qsb.length() > 0)
 179               {
 180                 qsb.append(fetcher.getAccessionSeparator());
 181               }
 182               String q = queriesLeft.pop();
 183               queriesMade.add(q);
 184               qsb.append(q);
 185             } while (doMultiple && !queriesLeft.isEmpty());
 186
 187             AlignmentI seqset = null;
 188             try
 189             {
 190               // create a fetcher and go to it
 191               seqset = fetcher.getSequenceRecords(qsb.toString());
 192             } catch (Exception ex)
 193             {
 194               System.err.println("Failed to retrieve the following from "
 195                       + db);
 196               System.err.println(qsb);
 197               ex.printStackTrace(System.err);
 198             }
 199             // TODO: Merge alignment together - perhaps
 200             if (seqset != null)
 201             {
 202               SequenceI seqs[] = seqset.getSequencesArray();
 203               if (seqs != null)
 204               {
 205                 for (int is = 0; is < seqs.length; is++)
 206                 {
 207                   rseqs.addElement(seqs[is]);
 208                   DBRefEntry[] frefs = DBRefUtils.searchRefs(seqs[is]
 209                           .getDBRefs(), new DBRefEntry(db, null, null));
 210                   if (frefs != null)
 211                   {
 212                     for (DBRefEntry dbr : frefs)
 213                     {
 214                       queriesFound.add(dbr.getAccessionId());
 215                       queriesMade.remove(dbr.getAccessionId());
 216                     }
 217                   }
 218                   seqs[is] = null;
 219                 }
 220               }
 221               else
 222               {
 223                 if (fetcher.getRawRecords() != null)
 224                 {
 225                   System.out.println("# Retrieved from " + db + ":"
 226                           + qsb.toString());
 227                   StringBuffer rrb = fetcher.getRawRecords();
 228                   /*
 229                    * for (int rr = 0; rr<rrb.length; rr++) {
 230                    */
 231                   String hdr;
 232                   // if (rr<qs.length)
 233                   // {
 234                   hdr = "# " + db + ":" + qsb.toString();
 235                   /*
 236                    * } else { hdr = "# part "+rr; }
 237                    */
 238                   System.out.println(hdr);
 239                   if (rrb != null)
 240                   {
 241                     System.out.println(rrb);
 242                   }
 243                   System.out.println("# end of " + hdr);
 244                 }
 245
 246               }
 247             }
 248
 249           }
 250         } catch (Exception ex)
 251         {
 252           reportStdError(db, queriesMade, ex);
 253         }
 254         if (queriesMade.size() > 0)
 255         {
 256           System.out.println("# Adding " + queriesMade.size()
 257                   + " ids back to queries list for searching again (" + db
 258                   + ")");
 259           queriesLeft.addAll(queriesMade);
 260         }
 261       }
 262     }
 263
 264     SequenceI[] result = null;
 265     if (rseqs.size() > 0)
 266     {
 267       result = new SequenceI[rseqs.size()];
 268       int si = 0;
 269       for (SequenceI s : rseqs)
 270       {
 271         result[si++] = s;
 272         s.updatePDBIds();
 273       }
 274     }
 275     return result;
 276   }
 277
 278   public void reportStdError(String db, List<String> queriesMade,
 279           Exception ex)
 280   {
 281
 282     System.err.println("Failed to retrieve the following references from "
 283             + db);
 284     int n = 0;
 285     for (String qv : queriesMade)
 286     {
 287       System.err.print(" " + qv + ";");
 288       if (n++ > 10)
 289       {
 290         System.err.println();
 291         n = 0;
 292       }
 293     }
 294     System.err.println();
 295     ex.printStackTrace();
 296   }
 297
 298   /**
 299    * Returns a list of proxies for the given source
 300    *
 301    * @param db
 302    *          database source string TODO: add version string/wildcard for
 303    *          retrieval of specific DB source/version combinations.
 304    * @return a list of DbSourceProxy for the db
 305    */
 306   public List<DbSourceProxy> getSourceProxy(String db)
 307   {
 308     db = DBRefUtils.getCanonicalName(db);
 309     Map<String, DbSourceProxy> dblist = fetchableDbs.get(db);
 310     if (dblist == null)
 311     {
 312       return new ArrayList<DbSourceProxy>();
 313     }
 314
 315     /*
 316      * sort so that primary sources precede secondary
 317      */
 318     List<DbSourceProxy> dbs = new ArrayList<DbSourceProxy>(dblist.values());
 319     Collections.sort(dbs, proxyComparator);
 320     return dbs;
 321   }
 322
 323   /**
 324    * constructs an instance of the proxy and registers it as a valid dbrefsource
 325    *
 326    * @param dbSourceProxy
 327    *          reference for class implementing
 328    *          jalview.ws.seqfetcher.DbSourceProxy
 329    */
 330   protected void addDBRefSourceImpl(
 331           Class<? extends DbSourceProxy> dbSourceProxy)
 332           throws IllegalArgumentException
 333   {
 334     DbSourceProxy proxy = null;
 335     try
 336     {
 337       DbSourceProxy proxyObj = dbSourceProxy.getConstructor().newInstance();
 338       proxy = proxyObj;
 339     } catch (IllegalArgumentException e)
 340     {
 341       throw e;
 342     } catch (Exception e)
 343     {
 344       // Serious problems if this happens.
 345       throw new Error(
 346               MessageManager
 347                       .getString("error.dbrefsource_implementation_exception"),
 348               e);
 349     }
 350     addDbRefSourceImpl(proxy);
 351   }
 352
 353   /**
 354    * add the properly initialised DbSourceProxy object 'proxy' to the list of
 355    * sequence fetchers
 356    *
 357    * @param proxy
 358    */
 359   protected void addDbRefSourceImpl(DbSourceProxy proxy)
 360   {
 361     if (proxy != null)
 362     {
 363       if (fetchableDbs == null)
 364       {
 365         fetchableDbs = new Hashtable<String, Map<String, DbSourceProxy>>();
 366       }
 367       Map<String, DbSourceProxy> slist = fetchableDbs.get(proxy
 368               .getDbSource());
 369       if (slist == null)
 370       {
 371         fetchableDbs.put(proxy.getDbSource(),
 372                 slist = new Hashtable<String, DbSourceProxy>());
 373       }
 374       slist.put(proxy.getDbName(), proxy);
 375     }
 376   }
 377
 378   /**
 379    * select sources which are implemented by instances of the given class
 380    *
 381    * @param class that implements DbSourceProxy
 382    * @return null or vector of source names for fetchers
 383    */
 384   public String[] getDbInstances(Class class1)
 385   {
 386     if (!DbSourceProxy.class.isAssignableFrom(class1))
 387     {
 388       throw new Error(
 389               MessageManager
 390                       .formatMessage(
 391                               "error.implementation_error_dbinstance_must_implement_interface",
 392                               new String[] { class1.toString() }));
 393     }
 394     if (fetchableDbs == null)
 395     {
 396       return null;
 397     }
 398     String[] sources = null;
 399     Vector<String> src = new Vector<String>();
 400     Enumeration<String> dbs = fetchableDbs.keys();
 401     while (dbs.hasMoreElements())
 402     {
 403       String dbn = dbs.nextElement();
 404       for (DbSourceProxy dbp : fetchableDbs.get(dbn).values())
 405       {
 406         if (class1.isAssignableFrom(dbp.getClass()))
 407         {
 408           src.addElement(dbn);
 409         }
 410       }
 411     }
 412     if (src.size() > 0)
 413     {
 414       src.copyInto(sources = new String[src.size()]);
 415     }
 416     return sources;
 417   }
 418
 419   public DbSourceProxy[] getDbSourceProxyInstances(Class class1)
 420   {
 421     List<DbSourceProxy> prlist = new ArrayList<DbSourceProxy>();
 422     for (String fetchable : getSupportedDb())
 423     {
 424       for (DbSourceProxy pr : getSourceProxy(fetchable))
 425       {
 426         if (class1.isInstance(pr))
 427         {
 428           prlist.add(pr);
 429         }
 430       }
 431     }
 432     if (prlist.size() == 0)
 433     {
 434       return null;
 435     }
 436     return prlist.toArray(new DbSourceProxy[0]);
 437   }
 438
 439   /**
 440    * Returns a preferred feature colouring scheme for the given source, or null
 441    * if none is defined.
 442    *
 443    * @param source
 444    * @return
 445    */
 446   public FeatureSettingsModelI getFeatureColourScheme(String source)
 447   {
 448     /*
 449      * return the first non-null colour scheme for any proxy for
 450      * this database source
 451      */
 452     for (DbSourceProxy proxy : getSourceProxy(source))
 453     {
 454       FeatureSettingsModelI preferredColours = proxy
 455               .getFeatureColourScheme();
 456       if (preferredColours != null)
 457       {
 458         return preferredColours;
 459       }
 460     }
 461     return null;
 462   }
 463 }