X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fanalysis%2FCrossRef.java;h=21fd08ddcfe55e8c931f4e96660e068a54c547a2;hb=a6b324e3f5edac3df0b968f0037b1cc8b651598e;hp=a71e61419fdbe53928ad17d5fbc07db3ee6e70be;hpb=5b079109d33a4596a8c3017dbf93b7de5b0300c5;p=jalview.git

diff --git a/src/jalview/analysis/CrossRef.java b/src/jalview/analysis/CrossRef.java
index a71e614..21fd08d 100644
--- a/src/jalview/analysis/CrossRef.java
+++ b/src/jalview/analysis/CrossRef.java
@@ -25,6 +25,7 @@ import jalview.datamodel.Alignment;
 import jalview.datamodel.AlignmentI;
 import jalview.datamodel.DBRefEntry;
 import jalview.datamodel.DBRefSource;
+import jalview.datamodel.Mapping;
 import jalview.datamodel.Sequence;
 import jalview.datamodel.SequenceI;
 import jalview.util.DBRefUtils;
@@ -88,41 +89,54 @@ public class CrossRef
   {
     String[] dbrefs = null;
     List<String> refs = new ArrayList<String>();
-    for (int s = 0; s < seqs.length; s++)
+    for (SequenceI seq : seqs)
     {
-      if (seqs[s] != null)
+      if (seq != null)
       {
-        SequenceI dss = seqs[s];
+        SequenceI dss = seq;
         while (dss.getDatasetSequence() != null)
         {
           dss = dss.getDatasetSequence();
         }
         DBRefEntry[] rfs = findXDbRefs(dna, dss.getDBRefs());
-        for (int r = 0; rfs != null && r < rfs.length; r++)
+        if (rfs != null)
         {
-          if (!refs.contains(rfs[r].getSource()))
+          for (DBRefEntry ref : rfs)
           {
-            refs.add(rfs[r].getSource());
+            if (!refs.contains(ref.getSource()))
+            {
+              refs.add(ref.getSource());
+            }
           }
         }
         if (dataset != null)
         {
           // search for references to this sequence's direct references.
-          DBRefEntry[] lrfs = CrossRef
-                  .findXDbRefs(!dna, seqs[s].getDBRefs());
+          DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seq.getDBRefs());
           List<SequenceI> rseqs = new ArrayList<SequenceI>();
-          CrossRef.searchDatasetXrefs(seqs[s], !dna, lrfs, dataset, rseqs,
+          CrossRef.searchDatasetXrefs(seq, !dna, lrfs, dataset, rseqs,
                   null); // don't need to specify codon frame for mapping here
           for (SequenceI rs : rseqs)
           {
-            DBRefEntry[] xrs = findXDbRefs(dna, rs.getDBRefs()); // not used??
-            for (int r = 0; rfs != null && r < rfs.length; r++)
+            DBRefEntry[] xrs = findXDbRefs(dna, rs.getDBRefs());
+            if (xrs != null)
             {
-              if (!refs.contains(rfs[r].getSource()))
+              for (DBRefEntry ref : xrs)
               {
-                refs.add(rfs[r].getSource());
+                if (!refs.contains(ref.getSource()))
+                {
+                  refs.add(ref.getSource());
+                }
               }
             }
+            // looks like copy and paste - change rfs to xrs?
+            // for (int r = 0; rfs != null && r < rfs.length; r++)
+            // {
+            // if (!refs.contains(rfs[r].getSource()))
+            // {
+            // refs.add(rfs[r].getSource());
+            // }
+            // }
           }
         }
       }
@@ -135,13 +149,9 @@ public class CrossRef
     return dbrefs;
   }
 
-  /*
-   * if (dna) { if (rfs[r].hasMap()) { // most likely this is a protein cross
-   * reference if (!refs.contains(rfs[r].getSource())) {
-   * refs.addElement(rfs[r].getSource()); } } }
-   */
   public static boolean hasCdnaMap(SequenceI[] seqs)
   {
+    // TODO unused - remove?
     String[] reftypes = findSequenceXrefTypes(false, seqs);
     for (int s = 0; s < reftypes.length; s++)
     {
@@ -156,6 +166,7 @@ public class CrossRef
 
   public static SequenceI[] getCdnaMap(SequenceI[] seqs)
   {
+    // TODO unused - remove?
     Vector cseqs = new Vector();
     for (int s = 0; s < seqs.length; s++)
     {
@@ -199,7 +210,9 @@ public class CrossRef
   /**
    * 
    * @param seqs
+   *          sequences whose xrefs are being retrieved
    * @param dna
+   *          true if sequences are nucleotide
    * @param source
    * @param dataset
    *          alignment to search for product sequences.
@@ -209,11 +222,10 @@ public class CrossRef
           String source, AlignmentI dataset)
   {
     List<SequenceI> rseqs = new ArrayList<SequenceI>();
-    Alignment ral = null;
-    AlignedCodonFrame cf = new AlignedCodonFrame(); // nominal width
-    for (int s = 0; s < seqs.length; s++)
+    AlignedCodonFrame cf = new AlignedCodonFrame();
+    for (SequenceI seq : seqs)
     {
-      SequenceI dss = seqs[s];
+      SequenceI dss = seq;
       while (dss.getDatasetSequence() != null)
       {
         dss = dss.getDatasetSequence();
@@ -223,7 +235,8 @@ public class CrossRef
       if ((xrfs == null || xrfs.length == 0) && dataset != null)
       {
         System.out.println("Attempting to find ds Xrefs refs.");
-        DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seqs[s].getDBRefs());
+        // FIXME should be dss not seq here?
+        DBRefEntry[] lrfs = CrossRef.findXDbRefs(!dna, seq.getDBRefs());
         // less ambiguous would be a 'find primary dbRefEntry' method.
         // filter for desired source xref here
         found = CrossRef.searchDatasetXrefs(dss, !dna, lrfs, dataset,
@@ -231,29 +244,30 @@ public class CrossRef
       }
       for (int r = 0; xrfs != null && r < xrfs.length; r++)
       {
-        if (source != null && !source.equals(xrfs[r].getSource()))
+        DBRefEntry xref = xrfs[r];
+        if (source != null && !source.equals(xref.getSource()))
         {
           continue;
         }
-        if (xrfs[r].hasMap())
+        if (xref.hasMap())
         {
-          if (xrfs[r].getMap().getTo() != null)
+          if (xref.getMap().getTo() != null)
           {
-            SequenceI rsq = new Sequence(xrfs[r].getMap().getTo());
+            SequenceI rsq = new Sequence(xref.getMap().getTo());
             rseqs.add(rsq);
-            if (xrfs[r].getMap().getMap().getFromRatio() != xrfs[r]
+            if (xref.getMap().getMap().getFromRatio() != xref
                     .getMap().getMap().getToRatio())
             {
               // get sense of map correct for adding to product alignment.
               if (dna)
               {
                 // map is from dna seq to a protein product
-                cf.addMap(dss, rsq, xrfs[r].getMap().getMap());
+                cf.addMap(dss, rsq, xref.getMap().getMap());
               }
               else
               {
                 // map should be from protein seq to its coding dna
-                cf.addMap(rsq, dss, xrfs[r].getMap().getMap().getInverse());
+                cf.addMap(rsq, dss, xref.getMap().getMap().getInverse());
               }
             }
             found = true;
@@ -265,7 +279,7 @@ public class CrossRef
           // xrefs on this sequence.
           if (dataset != null)
           {
-            found |= searchDataset(dss, xrfs[r], dataset, rseqs, cf); // ,false,!dna);
+            found |= searchDataset(dss, xref, dataset, rseqs, cf); // ,false,!dna);
             if (found)
             {
               xrfs[r] = null; // we've recovered seqs for this one.
@@ -313,15 +327,14 @@ public class CrossRef
             xrfs = t;
             try
             {
-              retrieved = sftch.getSequences(xrfs); // problem here is we don't
-              // know which of xrfs
-              // resulted in which
+              retrieved = sftch.getSequences(xrfs, !dna);
+              // problem here is we don't know which of xrfs resulted in which
               // retrieved element
             } catch (Exception e)
             {
               System.err
                       .println("Problem whilst retrieving cross references for Sequence : "
-                              + seqs[s].getName());
+                              + seq.getName());
               e.printStackTrace();
             }
             if (retrieved != null)
@@ -329,15 +342,14 @@ public class CrossRef
               for (int rs = 0; rs < retrieved.length; rs++)
               {
                 // TODO: examine each sequence for 'redundancy'
-                jalview.datamodel.DBRefEntry[] dbr = retrieved[rs]
-                        .getDBRefs();
+                DBRefEntry[] dbr = retrieved[rs].getDBRefs();
                 if (dbr != null && dbr.length > 0)
                 {
                   for (int di = 0; di < dbr.length; di++)
                   {
                     // find any entry where we should put in the sequence being
                     // cross-referenced into the map
-                    jalview.datamodel.Mapping map = dbr[di].getMap();
+                    Mapping map = dbr[di].getMap();
                     if (map != null)
                     {
                       if (map.getTo() != null && map.getMap() != null)
@@ -382,12 +394,14 @@ public class CrossRef
         }
       }
     }
+
+    Alignment ral = null;
     if (rseqs.size() > 0)
     {
       SequenceI[] rsqs = new SequenceI[rseqs.size()];
       rseqs.toArray(rsqs);
       ral = new Alignment(rsqs);
-      if (cf != null && cf.getProtMappings() != null)
+      if (cf != null && !cf.isEmpty())
       {
         ral.addCodonFrame(cf);
       }