X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fws%2Fseqfetcher%2FASequenceFetcher.java;h=d4501d871cfd6521d6845b2419b19e11d9c867de;hb=05539806560b8f623b152362251ca5b651907ade;hp=d4bcfe8277af119a8f7715cec9274fba1041f932;hpb=797df64fa2a0a30773d0f48f5494d4155e5a8be3;p=jalview.git

diff --git a/src/jalview/ws/seqfetcher/ASequenceFetcher.java b/src/jalview/ws/seqfetcher/ASequenceFetcher.java
index d4bcfe8..d4501d8 100644
--- a/src/jalview/ws/seqfetcher/ASequenceFetcher.java
+++ b/src/jalview/ws/seqfetcher/ASequenceFetcher.java
@@ -18,10 +18,19 @@
 package jalview.ws.seqfetcher;
 
 import jalview.datamodel.AlignmentI;
+import jalview.datamodel.DBRefEntry;
 import jalview.datamodel.SequenceI;
+import jalview.util.DBRefUtils;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Enumeration;
+import java.util.HashSet;
 import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
 import java.util.Vector;
 
 public class ASequenceFetcher
@@ -30,7 +39,7 @@ public class ASequenceFetcher
   /**
    * set of databases we can retrieve entries from
    */
-  protected Hashtable FETCHABLEDBS;
+  protected Hashtable<String, Map<String, DbSourceProxy>> FETCHABLEDBS;
 
   public ASequenceFetcher()
   {
@@ -75,120 +84,136 @@ public class ASequenceFetcher
   public SequenceI[] getSequences(jalview.datamodel.DBRefEntry[] refs)
   {
     SequenceI[] ret = null;
-    Vector rseqs = new Vector();
-    Hashtable queries = new Hashtable();
+    Vector<SequenceI> rseqs = new Vector();
+    Hashtable<String, List<String>> queries = new Hashtable();
     for (int r = 0; r < refs.length; r++)
     {
       if (!queries.containsKey(refs[r].getSource()))
       {
-        queries.put(refs[r].getSource(), new Vector());
+        queries.put(refs[r].getSource(), new ArrayList<String>());
       }
-      Vector qset = (Vector) queries.get(refs[r].getSource());
+      List<String> qset = queries.get(refs[r].getSource());
       if (!qset.contains(refs[r].getAccessionId()))
       {
-        qset.addElement(refs[r].getAccessionId());
+        qset.add(refs[r].getAccessionId());
       }
     }
-    Enumeration e = queries.keys();
+    Enumeration<String> e = queries.keys();
     while (e.hasMoreElements())
     {
-      Vector query = null;
+      List<String> query = null;
       String db = null;
-      try
+      db = e.nextElement();
+      query = queries.get(db);
+      if (!isFetchable(db))
       {
-        db = (String) e.nextElement();
-        query = (Vector) queries.get(db);
-        if (!isFetchable(db))
-          throw new Exception(
-                  "Don't know how to fetch from this database :" + db);
-        DbSourceProxy fetcher = getSourceProxy(db);
-        boolean doMultiple = fetcher.getAccessionSeparator() != null; // No
-        // separator
-        // - no
-        // Multiple
-        // Queries
-        Enumeration qs = query.elements();
-        while (qs.hasMoreElements())
+        reportStdError(db, query, new Exception(
+                "Don't know how to fetch from this database :" + db));
+        continue;
+      }
+      Iterator<DbSourceProxy> fetchers = getSourceProxy(db).iterator();
+      Stack<String> queriesLeft = new Stack<String>();
+//      List<String> queriesFailed = new ArrayList<String>();
+      queriesLeft.addAll(query);
+      while (fetchers.hasNext())
+      {
+        List<String> queriesMade = new ArrayList<String>();
+        HashSet queriesFound = new HashSet<String>();
+        try
         {
-          StringBuffer qsb = new StringBuffer();
-          do
-          {
-            qsb.append((String) qs.nextElement());
-            if (qs.hasMoreElements() && doMultiple) // and not reached limit for
-            // multiple queries at one
-            // time for this source
-            {
-              qsb.append(fetcher.getAccessionSeparator());
-            }
-          } while (doMultiple && qs.hasMoreElements());
-
-          AlignmentI seqset = null;
-          try
-          {
-            // create a fetcher and go to it
-            seqset = fetcher.getSequenceRecords(qsb.toString());
-          } catch (Exception ex)
+          DbSourceProxy fetcher = fetchers.next();
+          boolean doMultiple = fetcher.getAccessionSeparator() != null; // No
+          // separator
+          // - no
+          // Multiple
+          // Queries
+          while (!queriesLeft.isEmpty())
           {
-            System.err.println("Failed to retrieve the following from "
-                    + db);
-            System.err.println(qsb);
-            ex.printStackTrace(System.err);
-          }
-          // TODO: Merge alignment together - perhaps
-          if (seqset != null)
-          {
-            SequenceI seqs[] = seqset.getSequencesArray();
-            if (seqs != null)
+            StringBuffer qsb = new StringBuffer();
+            do
             {
-              for (int is = 0; is < seqs.length; is++)
+              if (qsb.length() > 0)
               {
-                rseqs.addElement(seqs[is]);
-                seqs[is] = null;
+                qsb.append(fetcher.getAccessionSeparator());
               }
+              String q = queriesLeft.pop();
+              queriesMade.add(q);
+              qsb.append(q);
+            } while (doMultiple && !queriesLeft.isEmpty());
+
+            AlignmentI seqset = null;
+            try
+            {
+              // create a fetcher and go to it
+              seqset = fetcher.getSequenceRecords(qsb.toString()); // ,
+                      // queriesFailed);
+            } catch (Exception ex)
+            {
+              System.err.println("Failed to retrieve the following from "
+                      + db);
+              System.err.println(qsb);
+              ex.printStackTrace(System.err);
             }
-            else
+            // TODO: Merge alignment together - perhaps
+            if (seqset != null)
             {
-              if (fetcher.getRawRecords() != null)
+              SequenceI seqs[] = seqset.getSequencesArray();
+              if (seqs != null)
               {
-                System.out.println("# Retrieved from " + db + ":"
-                        + qs.toString());
-                StringBuffer rrb = fetcher.getRawRecords();
-                /*
-                 * for (int rr = 0; rr<rrb.length; rr++) {
-                 */
-                String hdr;
-                // if (rr<qs.length)
-                // {
-                hdr = "# " + db + ":" + qsb.toString();
-                /*
-                 * } else { hdr = "# part "+rr; }
-                 */
-                System.out.println(hdr);
-                if (rrb != null)
-                  System.out.println(rrb);
-                System.out.println("# end of " + hdr);
+                for (int is = 0; is < seqs.length; is++)
+                {
+                  rseqs.addElement(seqs[is]);
+                  DBRefEntry[] frefs = DBRefUtils.searchRefs(seqs[is]
+                          .getDBRef(), new DBRefEntry(db, null, null));
+                  if (frefs != null)
+                  {
+                    for (DBRefEntry dbr : frefs)
+                    {
+                      queriesFound.add(dbr.getAccessionId());
+                      queriesMade.remove(dbr.getAccessionId());
+                    }
+                  }
+                  seqs[is] = null;
+                }
+              }
+              else
+              {
+                if (fetcher.getRawRecords() != null)
+                {
+                  System.out.println("# Retrieved from " + db + ":"
+                          + qsb.toString());
+                  StringBuffer rrb = fetcher.getRawRecords();
+                  /*
+                   * for (int rr = 0; rr<rrb.length; rr++) {
+                   */
+                  String hdr;
+                  // if (rr<qs.length)
+                  // {
+                  hdr = "# " + db + ":" + qsb.toString();
+                  /*
+                   * } else { hdr = "# part "+rr; }
+                   */
+                  System.out.println(hdr);
+                  if (rrb != null)
+                    System.out.println(rrb);
+                  System.out.println("# end of " + hdr);
+                }
+
               }
             }
+
           }
+        } catch (Exception ex)
+        {
+          reportStdError(db, queriesMade, ex);
         }
-      } catch (Exception ex)
-      {
-        System.err
-                .println("Failed to retrieve the following references from "
-                        + db);
-        Enumeration qv = query.elements();
-        int n = 0;
-        while (qv.hasMoreElements())
+        if (queriesMade.size() > 0)
         {
-          System.err.print(" " + qv.nextElement() + ";");
-          if (n++ > 10)
-          {
-            System.err.println();
-            n = 0;
-          }
+          System.out.println("# Adding " + queriesMade.size()
+                  + " ids back to queries list for searching again (" + db
+                  + ".");
+          queriesLeft.addAll(queriesMade);
         }
-        System.err.println();
-        ex.printStackTrace();
       }
     }
     if (rseqs.size() > 0)
@@ -206,6 +231,26 @@ public class ASequenceFetcher
     return ret;
   }
 
+  public void reportStdError(String db, List<String> queriesMade,
+          Exception ex)
+  {
+
+    System.err.println("Failed to retrieve the following references from "
+            + db);
+    int n = 0;
+    for (String qv : queriesMade)
+    {
+      System.err.print(" " + qv + ";");
+      if (n++ > 10)
+      {
+        System.err.println();
+        n = 0;
+      }
+    }
+    System.err.println();
+    ex.printStackTrace();
+  }
+
   /**
    * Retrieve an instance of the proxy for the given source
    * 
@@ -214,9 +259,28 @@ public class ASequenceFetcher
    *          retrieval of specific DB source/version combinations.
    * @return an instance of DbSourceProxy for that db.
    */
-  public DbSourceProxy getSourceProxy(String db)
+  public List<DbSourceProxy> getSourceProxy(String db)
   {
-    DbSourceProxy dbs = (DbSourceProxy) FETCHABLEDBS.get(db);
+    List<DbSourceProxy> dbs;
+    Collection<DbSourceProxy> dblist = FETCHABLEDBS.get(db).values();
+    if (dblist.size()>1)
+    {
+      DbSourceProxy[] l=dblist.toArray(new DbSourceProxy[0]);
+      int i=0;
+      String[] nm=new String[l.length];
+      for (DbSourceProxy s:l)
+      {
+        nm[i++]=s.getDbName().toLowerCase();
+      }
+      jalview.util.QuickSort.sort(nm,l);
+      dbs = new ArrayList<DbSourceProxy>();
+      for (i=l.length-1;i>=0; i--)
+      {
+        dbs.add(l[i]);
+      }
+    } else {
+      dbs = new ArrayList<DbSourceProxy>(dblist);
+    }
     return dbs;
   }
 
@@ -268,15 +332,22 @@ public class ASequenceFetcher
     {
       if (FETCHABLEDBS == null)
       {
-        FETCHABLEDBS = new Hashtable();
+        FETCHABLEDBS = new Hashtable<String, Map<String,DbSourceProxy>>();
+      }
+      Map<String,DbSourceProxy> slist = FETCHABLEDBS.get(proxy.getDbSource());
+      if (slist == null)
+      {
+        FETCHABLEDBS.put(proxy.getDbSource(),
+                slist = new Hashtable<String,DbSourceProxy>());
       }
-      FETCHABLEDBS.put(proxy.getDbSource(), proxy);
+      slist.put(proxy.getDbName(),proxy);
     }
   }
 
   /**
    * test if the database handler for dbName contains the given dbProperty
-   * 
+   * when a dbName resolves to a set of proxies - this method will return the result of the test for the first instance.
+   * TODO implement additional method to query all sources for a db to find one with a particular property
    * @param dbName
    * @param dbProperty
    * @return true if proxy has the given property
@@ -284,12 +355,16 @@ public class ASequenceFetcher
   public boolean hasDbSourceProperty(String dbName, String dbProperty)
   {
     // TODO: decide if invalidDbName exception is thrown here.
-    DbSourceProxy proxy = getSourceProxy(dbName);
-    if (proxy != null)
+
+    List<DbSourceProxy> proxies = getSourceProxy(dbName);
+    if (proxies != null)
     {
-      if (proxy.getDbSourceProperties() != null)
+      for (DbSourceProxy proxy : proxies)
       {
-        return proxy.getDbSourceProperties().containsKey(dbProperty);
+        if (proxy.getDbSourceProperties() != null)
+        {
+          return proxy.getDbSourceProperties().containsKey(dbProperty);
+        }
       }
     }
     return false;
@@ -319,10 +394,12 @@ public class ASequenceFetcher
     while (dbs.hasMoreElements())
     {
       String dbn = (String) dbs.nextElement();
-      DbSourceProxy dbp = (DbSourceProxy) FETCHABLEDBS.get(dbn);
-      if (class1.isAssignableFrom(dbp.getClass()))
+      for (DbSourceProxy dbp : FETCHABLEDBS.get(dbn).values())
       {
-        src.addElement(dbn);
+        if (class1.isAssignableFrom(dbp.getClass()))
+        {
+          src.addElement(dbn);
+        }
       }
     }
     if (src.size() > 0)
@@ -331,4 +408,20 @@ public class ASequenceFetcher
     }
     return sources;
   }
+  public DbSourceProxy[] getDbSourceProxyInstances(
+          Class class1)
+  {
+    ArrayList<DbSourceProxy> prlist=new ArrayList<DbSourceProxy>();
+    for (String fetchable:getSupportedDb())
+    for (DbSourceProxy pr:getSourceProxy(fetchable))
+    {
+      if (class1.isInstance(pr)) {prlist.add(pr);}
+    }
+    if (prlist.size()==0)
+    {
+      return null;
+    }
+    return prlist.toArray(new DbSourceProxy[0]);
+  }
+
 }