X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Futil%2FDBRefUtils.java;h=32589f711df95d6c44896e01f258a8aac4caa707;hb=17e77c3f2949a0729322b4a8d907f3f34b6a9914;hp=70ef47cab0e895072ccc83f925d4c7b5a9e2ef7e;hpb=797df64fa2a0a30773d0f48f5494d4155e5a8be3;p=jalview.git

diff --git a/src/jalview/util/DBRefUtils.java b/src/jalview/util/DBRefUtils.java
index 70ef47c..32589f7 100755
--- a/src/jalview/util/DBRefUtils.java
+++ b/src/jalview/util/DBRefUtils.java
@@ -1,28 +1,58 @@
 /*
- * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
- * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
+ * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9)
+ * Copyright (C) 2015 The Jalview Authors
  * 
  * This file is part of Jalview.
  * 
  * Jalview is free software: you can redistribute it and/or
  * modify it under the terms of the GNU General Public License 
- * as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
- * 
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ *  
  * Jalview is distributed in the hope that it will be useful, but 
  * WITHOUT ANY WARRANTY; without even the implied warranty 
  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
  * PURPOSE.  See the GNU General Public License for more details.
  * 
- * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
  */
 package jalview.util;
 
-import java.util.*;
+import jalview.datamodel.DBRefEntry;
+import jalview.datamodel.DBRefSource;
+import jalview.datamodel.PDBEntry;
+import jalview.datamodel.SequenceI;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Map;
 
-import jalview.datamodel.*;
+import com.stevesoft.pat.Regex;
 
 public class DBRefUtils
 {
+  private static Map<String, String> canonicalSourceNameLookup = new HashMap<String, String>();
+
+  private static Map<String, String> dasCoordinateSystemsLookup = new HashMap<String, String>();
+
+  static
+  {
+    // TODO load these from a resource file?
+    canonicalSourceNameLookup.put("uniprotkb/swiss-prot",
+            DBRefSource.UNIPROT);
+    canonicalSourceNameLookup.put("uniprotkb/trembl", DBRefSource.UNIPROT);
+    canonicalSourceNameLookup.put("pdb", DBRefSource.PDB);
+
+    dasCoordinateSystemsLookup.put("pdbresnum", DBRefSource.PDB);
+    dasCoordinateSystemsLookup.put("uniprot", DBRefSource.UNIPROT);
+    dasCoordinateSystemsLookup.put("embl", DBRefSource.EMBL);
+    // dasCoordinateSystemsLookup.put("embl", DBRefSource.EMBLCDS);
+  }
+
   /**
    * Utilities for handling DBRef objects and their collections.
    */
@@ -45,8 +75,8 @@ public class DBRefUtils
     {
       return dbrefs;
     }
-    Hashtable srcs = new Hashtable();
-    Vector res = new Vector();
+    Map<String, Integer> srcs = new HashMap<String, Integer>();
+    ArrayList<DBRefEntry> res = new ArrayList<DBRefEntry>();
 
     for (int i = 0; i < sources.length; i++)
     {
@@ -56,18 +86,14 @@ public class DBRefUtils
     {
       if (srcs.containsKey(dbrefs[i].getSource()))
       {
-        res.addElement(dbrefs[i]);
+        res.add(dbrefs[i]);
       }
     }
 
     if (res.size() > 0)
     {
       DBRefEntry[] reply = new DBRefEntry[res.size()];
-      for (int i = 0; i < res.size(); i++)
-      {
-        reply[i] = (DBRefEntry) res.elementAt(i);
-      }
-      return reply;
+      return res.toArray(reply);
     }
     res = null;
     // there are probable memory leaks in the hashtable!
@@ -84,37 +110,19 @@ public class DBRefUtils
    * @return boolean true if Source DBRefEntry is compatible with DAS
    *         CoordinateSystem name
    */
-  public static Hashtable DasCoordinateSystemsLookup = null;
 
   public static boolean isDasCoordinateSystem(String string,
           DBRefEntry dBRefEntry)
   {
-    if (DasCoordinateSystemsLookup == null)
-    {
-      // TODO: Make a DasCoordinateSystemsLookup properties resource
-      // Initialise
-      DasCoordinateSystemsLookup = new Hashtable();
-      DasCoordinateSystemsLookup.put("pdbresnum",
-              jalview.datamodel.DBRefSource.PDB);
-      DasCoordinateSystemsLookup.put("uniprot",
-              jalview.datamodel.DBRefSource.UNIPROT);
-      DasCoordinateSystemsLookup.put("EMBL",
-              jalview.datamodel.DBRefSource.EMBL);
-      // DasCoordinateSystemsLookup.put("EMBL",
-      // jalview.datamodel.DBRefSource.EMBLCDS);
-    }
-
-    String coordsys = (String) DasCoordinateSystemsLookup.get(string
-            .toLowerCase());
-    if (coordsys != null)
+    if (string == null || dBRefEntry == null)
     {
-      return coordsys.equals(dBRefEntry.getSource());
+      return false;
     }
-    return false;
+    String coordsys = dasCoordinateSystemsLookup.get(string.toLowerCase());
+    return coordsys == null ? false : coordsys.equals(dBRefEntry
+            .getSource());
   }
 
-  public static Hashtable CanonicalSourceNameLookup = null;
-
   /**
    * look up source in an internal list of database reference sources and return
    * the canonical jalview name for the source, or the original string if it has
@@ -126,34 +134,27 @@ public class DBRefUtils
    */
   public static String getCanonicalName(String source)
   {
-    if (CanonicalSourceNameLookup == null)
-    {
-      CanonicalSourceNameLookup = new Hashtable();
-      CanonicalSourceNameLookup.put("uniprotkb/swiss-prot",
-              jalview.datamodel.DBRefSource.UNIPROT);
-      CanonicalSourceNameLookup.put("uniprotkb/trembl",
-              jalview.datamodel.DBRefSource.UNIPROT);
-      CanonicalSourceNameLookup.put("pdb",
-              jalview.datamodel.DBRefSource.PDB);
-    }
-    String canonical = (String) CanonicalSourceNameLookup.get(source
-            .toLowerCase());
-    if (canonical == null)
+    if (source == null)
     {
-      return source;
+      return null;
     }
-    return canonical;
+    String canonical = canonicalSourceNameLookup.get(source.toLowerCase());
+    return canonical == null ? source : canonical;
   }
 
   /**
-   * find RefEntry corresponding to a particular pattern the equals method of
-   * each entry is used, from String attributes right down to Mapping
-   * attributes.
+   * Returns an array of those references that match the given entry, or null if
+   * no matches. Currently uses a comparator which matches if
+   * <ul>
+   * <li>database sources are the same</li>
+   * <li>accession ids are the same</li>
+   * <li>both have no mapping, or the mappings are the same</li>
+   * </ul>
    * 
    * @param ref
    *          Set of references to search
    * @param entry
-   *          pattern to collect - null any entry for wildcard match
+   *          pattern to match
    * @return
    */
   public static DBRefEntry[] searchRefs(DBRefEntry[] ref, DBRefEntry entry)
@@ -162,30 +163,36 @@ public class DBRefUtils
             matchDbAndIdAndEitherMapOrEquivalentMapList);
   }
 
-  public static DBRefEntry[] searchRefs(DBRefEntry[] ref, DBRefEntry entry,
+  /**
+   * Returns an array of those references that match the given entry, according
+   * to the given comparator. Returns null if no matches.
+   * 
+   * @param refs
+   *          an array of database references to search
+   * @param entry
+   *          an entry to compare against
+   * @param comparator
+   * @return
+   */
+  static DBRefEntry[] searchRefs(DBRefEntry[] refs, DBRefEntry entry,
           DbRefComp comparator)
   {
-    if (ref == null || entry == null)
+    if (refs == null || entry == null)
+    {
       return null;
-    Vector rfs = new Vector();
-    for (int i = 0; i < ref.length; i++)
+    }
+    List<DBRefEntry> rfs = new ArrayList<DBRefEntry>();
+    for (int i = 0; i < refs.length; i++)
     {
-      if (comparator.matches(entry, ref[i]))
+      if (comparator.matches(entry, refs[i]))
       {
-        rfs.addElement(ref[i]);
+        rfs.add(refs[i]);
       }
     }
-    // TODO Auto-generated method stub
-    if (rfs.size() > 0)
-    {
-      DBRefEntry[] rf = new DBRefEntry[rfs.size()];
-      rfs.copyInto(rf);
-      return rf;
-    }
-    return null;
+    return rfs.size() == 0 ? null : rfs.toArray(new DBRefEntry[rfs.size()]);
   }
 
-  public interface DbRefComp
+  interface DbRefComp
   {
     public boolean matches(DBRefEntry refa, DBRefEntry refb);
   }
@@ -300,6 +307,7 @@ public class DBRefUtils
         {
           if ((refa.getMap() == null && refb.getMap() == null)
                   || (refa.getMap() != null && refb.getMap() != null))
+          {
             if ((refb.getMap().getMap() == null && refa.getMap().getMap() == null)
                     || (refb.getMap().getMap() != null
                             && refa.getMap().getMap() != null && refb
@@ -308,6 +316,7 @@ public class DBRefUtils
             {
               return true;
             }
+          }
         }
       }
       return false;
@@ -393,14 +402,17 @@ public class DBRefUtils
   };
 
   /**
-   * used by file parsers to generate DBRefs from annotation within file (eg
-   * stockholm)
+   * Parses a DBRefEntry and adds it to the sequence, also a PDBEntry if the
+   * database is PDB.
+   * <p>
+   * Used by file parsers to generate DBRefs from annotation within file (eg
+   * Stockholm)
    * 
    * @param dbname
    * @param version
    * @param acn
    * @param seq
-   *          where to anotate with reference
+   *          where to annotate with reference
    * @return parsed version of entry that was added to seq (if any)
    */
   public static DBRefEntry parseToDbRef(SequenceI seq, String dbname,
@@ -409,19 +421,25 @@ public class DBRefUtils
     DBRefEntry ref = null;
     if (dbname != null)
     {
-      String locsrc = jalview.util.DBRefUtils.getCanonicalName(dbname);
-      if (locsrc.equals(jalview.datamodel.DBRefSource.PDB))
+      String locsrc = DBRefUtils.getCanonicalName(dbname);
+      if (locsrc.equals(DBRefSource.PDB))
       {
-        // check for chaincode and mapping
-        // PFAM style stockhom PDB citation
-        com.stevesoft.pat.Regex r = new com.stevesoft.pat.Regex(
-                "([0-9][0-9A-Za-z]{3})\\s*(.?)\\s*;([0-9]+)-([0-9]+)");
+        /*
+         * Check for PFAM style stockhom PDB accession id citation e.g.
+         * "1WRI A; 7-80;"
+         */
+        Regex r = new com.stevesoft.pat.Regex(
+                "([0-9][0-9A-Za-z]{3})\\s*(.?)\\s*;\\s*([0-9]+)-([0-9]+)");
         if (r.search(acn.trim()))
         {
           String pdbid = r.stringMatched(1);
           String chaincode = r.stringMatched(2);
-          String mapstart = r.stringMatched(3);
-          String mapend = r.stringMatched(4);
+          if (chaincode == null)
+          {
+            chaincode = " ";
+          }
+          // String mapstart = r.stringMatched(3);
+          // String mapend = r.stringMatched(4);
           if (chaincode.equals(" "))
           {
             chaincode = "_";
@@ -430,8 +448,16 @@ public class DBRefUtils
           ref = new DBRefEntry(locsrc, version, pdbid + chaincode);
           PDBEntry pdbr = new PDBEntry();
           pdbr.setId(pdbid);
+          pdbr.setType(PDBEntry.Type.PDB);
+          pdbr.setProperty(new Hashtable());
+          pdbr.setChainCode(chaincode);
+          // pdbr.getProperty().put("CHAIN", chaincode);
           seq.addPDBId(pdbr);
         }
+        else
+        {
+          System.err.println("Malformed PDB DR line:" + acn);
+        }
       }
       else
       {