X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fanalysis%2FAlignmentSorter.java;h=881dc74b8020887d88325b805dfe58b7f0204b56;hb=fad3f340d7479114fd1c5e1ac1c089971d95b1c8;hp=d78b5b39d1a9224e57131b1bbedea07d30c7c4e1;hpb=a45774ee31d9f35d4eff46d54d7deab719afb092;p=jalview.git

diff --git a/src/jalview/analysis/AlignmentSorter.java b/src/jalview/analysis/AlignmentSorter.java
index d78b5b3..881dc74 100755
--- a/src/jalview/analysis/AlignmentSorter.java
+++ b/src/jalview/analysis/AlignmentSorter.java
@@ -1,18 +1,18 @@
 /*
  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
- * Copyright (C) 2011 J Procter, AM Waterhouse, G Barton, M Clamp, S Searle
- * 
+ * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
+ *
  * 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 
+ * 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.
- * 
- * 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 
+ *
+ * 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/>.
  */
 package jalview.analysis;
@@ -75,7 +75,7 @@ public class AlignmentSorter
 
   /**
    * Sort by Percentage Identity w.r.t. s
-   * 
+   *
    * @param align
    *          AlignmentI
    * @param s
@@ -91,7 +91,7 @@ public class AlignmentSorter
 
   /**
    * Sort by Percentage Identity w.r.t. s
-   * 
+   *
    * @param align
    *          AlignmentI
    * @param s
@@ -124,7 +124,7 @@ public class AlignmentSorter
 
   /**
    * Reverse the order of the sort
-   * 
+   *
    * @param align
    *          DOCUMENT ME!
    * @param seqs
@@ -146,17 +146,21 @@ public class AlignmentSorter
     }
 
     // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
-    for (int i = 0; i < len; i++)
+    List<SequenceI> asq;
+    synchronized (asq = align.getSequences())
     {
-      // SequenceI tmp = seqs[i];
-      align.getSequences().setElementAt(seqs[nSeq - i - 1], i);
-      align.getSequences().setElementAt(seqs[i], nSeq - i - 1);
+      for (int i = 0; i < len; i++)
+      {
+        // SequenceI tmp = seqs[i];
+        asq.set(i, seqs[nSeq - i - 1]);
+        asq.set(nSeq - i - 1, seqs[i]);
+      }
     }
   }
 
   /**
    * Sets the Alignment object with the given sequences
-   * 
+   *
    * @param align
    *          Alignment object to be updated
    * @param tmp
@@ -169,7 +173,7 @@ public class AlignmentSorter
 
   /**
    * Sets the Alignment object with the given sequences
-   * 
+   *
    * @param align
    *          DOCUMENT ME!
    * @param seqs
@@ -178,29 +182,31 @@ public class AlignmentSorter
   public static void setOrder(AlignmentI align, SequenceI[] seqs)
   {
     // NOTE: DO NOT USE align.setSequenceAt() here - it will NOT work
-    Vector algn = align.getSequences();
-    Vector tmp = new Vector();
-
-    for (int i = 0; i < seqs.length; i++)
+    List<SequenceI> algn;
+    synchronized (algn = align.getSequences())
     {
-      if (algn.contains(seqs[i]))
+      List<SequenceI> tmp = new ArrayList<SequenceI>();
+
+      for (int i = 0; i < seqs.length; i++)
       {
-        tmp.addElement(seqs[i]);
+        if (algn.contains(seqs[i]))
+        {
+          tmp.add(seqs[i]);
+        }
       }
-    }
 
-    algn.removeAllElements();
-    // User may have hidden seqs, then clicked undo or redo
-    for (int i = 0; i < tmp.size(); i++)
-    {
-      algn.addElement(tmp.elementAt(i));
+      algn.clear();
+      // User may have hidden seqs, then clicked undo or redo
+      for (int i = 0; i < tmp.size(); i++)
+      {
+        algn.add(tmp.get(i));
+      }
     }
-
   }
 
   /**
    * Sorts by ID. Numbers are sorted before letters.
-   * 
+   *
    * @param align
    *          The alignment object to sort
    */
@@ -233,7 +239,7 @@ public class AlignmentSorter
 
   /**
    * Sorts by sequence length
-   * 
+   *
    * @param align
    *          The alignment object to sort
    */
@@ -247,7 +253,7 @@ public class AlignmentSorter
     for (int i = 0; i < nSeq; i++)
     {
       seqs[i] = align.getSequenceAt(i);
-      length[i] = (float) (seqs[i].getEnd() - seqs[i].getStart());
+      length[i] = (seqs[i].getEnd() - seqs[i].getStart());
     }
 
     QuickSort.sort(length, seqs);
@@ -268,7 +274,7 @@ public class AlignmentSorter
    * Sorts the alignment by size of group. <br>
    * Maintains the order of sequences in each group by order in given alignment
    * object.
-   * 
+   *
    * @param align
    *          sorts the given alignment object by group
    */
@@ -290,10 +296,8 @@ public class AlignmentSorter
 
     // SORTS GROUPS BY SIZE
     // ////////////////////
-    for (int i = 0; i < align.getGroups().size(); i++)
+    for (SequenceGroup sg : align.getGroups())
     {
-      SequenceGroup sg = (SequenceGroup) align.getGroups().elementAt(i);
-
       for (int j = 0; j < groups.size(); j++)
       {
         SequenceGroup sg2 = (SequenceGroup) groups.elementAt(j);
@@ -340,10 +344,10 @@ public class AlignmentSorter
 
   /**
    * Converts Vector to array. java 1.18 does not have Vector.toArray()
-   * 
+   *
    * @param tmp
    *          Vector of SequenceI objects
-   * 
+   *
    * @return array of Sequence[]
    */
   private static SequenceI[] vectorToArray(Vector tmp)
@@ -359,18 +363,20 @@ public class AlignmentSorter
   }
 
   /**
-   * DOCUMENT ME!
-   * 
+   * Select sequences in order from tmp that is present in mask, and any
+   * remaining seqeunces in mask not in tmp
+   *
    * @param tmp
-   *          DOCUMENT ME!
+   *          thread safe collection of sequences
    * @param mask
-   *          DOCUMENT ME!
-   * 
-   * @return DOCUMENT ME!
+   *          thread safe collection of sequences
+   *
+   * @return intersect(tmp,mask)+intersect(complement(tmp),mask)
    */
-  private static SequenceI[] vectorSubsetToArray(Vector tmp, Vector mask)
+  private static SequenceI[] vectorSubsetToArray(List<SequenceI> tmp,
+          List<SequenceI> mask)
   {
-    Vector seqs = new Vector();
+    ArrayList<SequenceI> seqs = new ArrayList<SequenceI>();
     int i, idx;
     boolean[] tmask = new boolean[mask.size()];
 
@@ -381,12 +387,12 @@ public class AlignmentSorter
 
     for (i = 0; i < tmp.size(); i++)
     {
-      Object sq = tmp.elementAt(i);
+      SequenceI sq = tmp.get(i);
       idx = mask.indexOf(sq);
       if (idx > -1 && tmask[idx])
       {
         tmask[idx] = false;
-        seqs.addElement(sq);
+        seqs.add(sq);
       }
     }
 
@@ -394,16 +400,16 @@ public class AlignmentSorter
     {
       if (tmask[i])
       {
-        seqs.addElement(mask.elementAt(i));
+        seqs.add(mask.get(i));
       }
     }
 
-    return vectorToArray(seqs);
+    return seqs.toArray(new SequenceI[seqs.size()]);
   }
 
   /**
    * Sorts by a given AlignmentOrder object
-   * 
+   *
    * @param align
    *          Alignment to order
    * @param order
@@ -435,12 +441,12 @@ public class AlignmentSorter
 
   /**
    * DOCUMENT ME!
-   * 
+   *
    * @param align
    *          alignment to order
    * @param tree
    *          tree which has
-   * 
+   *
    * @return DOCUMENT ME!
    */
   private static Vector getOrderByTree(AlignmentI align, NJTree tree)
@@ -463,8 +469,12 @@ public class AlignmentSorter
 
       if (tmp.size() != nSeq)
       {
-        System.err.println("WARNING: tmp.size()=" + tmp.size() + " != nseq="
-                + nSeq + " in getOrderByTree - tree contains sequences not in alignment");
+        System.err
+                .println("WARNING: tmp.size()="
+                        + tmp.size()
+                        + " != nseq="
+                        + nSeq
+                        + " in getOrderByTree - tree contains sequences not in alignment");
       }
     }
 
@@ -473,7 +483,7 @@ public class AlignmentSorter
 
   /**
    * Sorts the alignment by a given tree
-   * 
+   *
    * @param align
    *          alignment to order
    * @param tree
@@ -506,7 +516,7 @@ public class AlignmentSorter
 
   /**
    * DOCUMENT ME!
-   * 
+   *
    * @param align
    *          DOCUMENT ME!
    * @param seqs
@@ -533,18 +543,18 @@ public class AlignmentSorter
 
   /**
    * DOCUMENT ME!
-   * 
+   *
    * @param node
    *          DOCUMENT ME!
    * @param tmp
    *          DOCUMENT ME!
    * @param seqset
    *          DOCUMENT ME!
-   * 
+   *
    * @return DOCUMENT ME!
    */
   private static Vector _sortByTree(SequenceNode node, Vector tmp,
-          Vector seqset)
+          List<SequenceI> seqset)
   {
     if (node == null)
     {
@@ -560,9 +570,11 @@ public class AlignmentSorter
       {
         if (node.element() instanceof SequenceI)
         {
-          if (!tmp.contains(node.element())) //  && (seqset==null || seqset.size()==0 || seqset.contains(tmp)))
+          if (!tmp.contains(node.element())) // && (seqset==null ||
+                                             // seqset.size()==0 ||
+                                             // seqset.contains(tmp)))
           {
-            tmp.addElement((SequenceI) node.element());
+            tmp.addElement(node.element());
           }
         }
       }
@@ -603,7 +615,7 @@ public class AlignmentSorter
   /**
    * Sort sequence in order of increasing score attribute for annotation with a
    * particular scoreLabel. Or reverse if same label was used previously
-   * 
+   *
    * @param scoreLabel
    *          exact label for sequence associated AlignmentAnnotation scores to
    *          use for sorting.
@@ -691,7 +703,7 @@ public class AlignmentSorter
   /**
    * sort the alignment using the features on each sequence found between start
    * and stop with the given featureLabel (and optional group qualifier)
-   * 
+   *
    * @param featureLabel
    *          (may not be null)
    * @param groupLabel