X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=fd4a9b5493f56348c130af1cb92eeec99695d007;hb=ecdbc96815298ac853543640881ef8d2384b48a1;hp=ea8da8dc964cca5e075e0c078fbd380efd304e83;hpb=8be202b71704e4b7e10e3a366446492623a3c322;p=jalview.git

diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java
index ea8da8d..fd4a9b5 100644
--- a/src/jalview/datamodel/HiddenColumns.java
+++ b/src/jalview/datamodel/HiddenColumns.java
@@ -33,13 +33,13 @@ import java.util.concurrent.locks.ReentrantReadWriteLock;
  * use an iterator obtained from one of:
  * 
  * - getBoundedIterator: iterates over the hidden regions, within some bounds,
- * returning absolute positions
+ * returning *absolute* positions
  * 
  * - getBoundedStartIterator: iterates over the start positions of hidden
- * regions, within some bounds, returning visible positions
+ * regions, within some bounds, returning *visible* positions
  * 
  * - getVisContigsIterator: iterates over visible regions in a range, returning
- * absolute positions
+ * *absolute* positions
  * 
  * - getVisibleColsIterator: iterates over the visible *columns*
  * 
@@ -47,12 +47,28 @@ import java.util.concurrent.locks.ReentrantReadWriteLock;
  * numbering begins at 0 throughout this class.
  * 
  * @author kmourao
- *
+ */
+
+/* Implementation notes:
+ * 
+ * Methods which change the hiddenColumns collection should use a writeLock to
+ * prevent other threads accessing the hiddenColumns collection while changes
+ * are being made. They should also reset the hidden columns cursor, and either
+ * update the hidden columns count, or set it to 0 (so that it will later be
+ * updated when needed).
+ * 
+ * 
+ * Methods which only need read access to the hidden columns collection should
+ * use a readLock to prevent other threads changing the hidden columns
+ * collection while it is in use.
  */
 public class HiddenColumns
 {
   private static final int HASH_MULTIPLIER = 31;
 
+  private static final int NUMCOLUMNS_RESET = -1; // value of numColumns if it
+                                                  // needs to be recalculated
+
   private static final ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock();
 
   /*
@@ -79,14 +95,6 @@ public class HiddenColumns
   {
   }
 
-  /* 
-   * Methods which change the hiddenColumns collection. These methods should 
-   * use a writeLock to prevent other threads accessing the hiddenColumns
-   * collection while changes are being made. They should also reset the hidden
-   * columns cursor, and either update the hidden columns count, or set it to 0 
-   * (so that it will later be updated when needed).
-   */
-
   /**
    * Copy constructor
    * 
@@ -135,7 +143,7 @@ public class HiddenColumns
             numColumns += region[1] - region[0] + 1;
           }
         }
-        cursor.resetCursor(hiddenColumns);
+        cursor = new HiddenColumnsCursor(hiddenColumns);
       }
     } finally
     {
@@ -153,19 +161,9 @@ public class HiddenColumns
    */
   public void hideColumns(int start, int end)
   {
-    boolean wasAlreadyLocked = false;
     try
     {
-      // check if the write lock was already locked by this thread,
-      // as this method can be called internally in loops within HiddenColumns
-      if (!LOCK.isWriteLockedByCurrentThread())
-      {
-        LOCK.writeLock().lock();
-      }
-      else
-      {
-        wasAlreadyLocked = true;
-      }
+      LOCK.writeLock().lock();
 
       int previndex = 0;
       int prevHiddenCount = 0;
@@ -173,7 +171,8 @@ public class HiddenColumns
       if (!hiddenColumns.isEmpty())
       {
         // set up cursor reset values
-        HiddenCursorPosition cursorPos = cursor.findRegionForColumn(start);
+        HiddenCursorPosition cursorPos = cursor.findRegionForColumn(start,
+                false);
         regionindex = cursorPos.getRegionIndex();
 
         if (regionindex > 0)
@@ -213,17 +212,15 @@ public class HiddenColumns
 
       // reset the cursor to just before our insertion point: this saves
       // a lot of reprocessing in large alignments
-      cursor.resetCursor(hiddenColumns, previndex, prevHiddenCount);
+      cursor = new HiddenColumnsCursor(hiddenColumns, previndex,
+              prevHiddenCount);
 
       // reset the number of columns so they will be recounted
-      numColumns = 0;
+      resetNumColumns();
 
     } finally
     {
-      if (!wasAlreadyLocked)
-      {
-        LOCK.writeLock().unlock();
-      }
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -286,9 +283,9 @@ public class HiddenColumns
         }
         region[1] = Math.max(nextRegion[1], end);
 
-        // in theory this is faster than hiddenColumns.remove(i+1)
-        // benchmarking results a bit ambivalent
-        hiddenColumns.subList(i + 1, i + 2).clear();
+        // in theory hiddenColumns.subList(i + 1, i + 2).clear() is faster than
+        // hiddenColumns.remove(i+1) but benchmarking results a bit ambivalent
+        hiddenColumns.remove(i + 1);
       }
       added = true;
     }
@@ -309,8 +306,8 @@ public class HiddenColumns
       {
         hideColumns(r[0], r[1]);
       }
-      cursor.resetCursor(hiddenColumns);
-      numColumns = 0;
+      cursor = new HiddenColumnsCursor(hiddenColumns);
+      resetNumColumns();
     } finally
     {
       LOCK.writeLock().unlock();
@@ -334,8 +331,8 @@ public class HiddenColumns
         }
       }
       hiddenColumns.clear();
-      cursor.resetCursor(hiddenColumns);
-      numColumns = 0;
+      cursor = new HiddenColumnsCursor(hiddenColumns);
+      resetNumColumns();
 
     } finally
     {
@@ -360,7 +357,7 @@ public class HiddenColumns
 
       if (!hiddenColumns.isEmpty())
       {
-        int regionIndex = cursor.findRegionForColumn(start)
+        int regionIndex = cursor.findRegionForColumn(start, false)
                 .getRegionIndex();
 
         if (regionIndex != -1 && regionIndex != hiddenColumns.size())
@@ -379,8 +376,7 @@ public class HiddenColumns
 
             if (hiddenColumns.isEmpty())
             {
-              hiddenColumns.clear();
-              numColumns = 0;
+              resetNumColumns();
             }
             else
             {
@@ -397,165 +393,6 @@ public class HiddenColumns
   }
 
   /**
-   * Add gaps into the sequences aligned to profileseq under the given
-   * AlignmentView
-   * 
-   * @param profileseq
-   *          sequence in al which sequences are aligned to
-   * @param al
-   *          alignment to have gaps inserted into it
-   * @param input
-   *          alignment view where sequence corresponding to profileseq is first
-   *          entry
-   * @return new HiddenColumns for new alignment view, with insertions into
-   *         profileseq marked as hidden.
-   */
-  public static HiddenColumns propagateInsertions(SequenceI profileseq,
-          AlignmentI al, AlignmentView input)
-  {
-    int profsqpos = 0;
-
-    char gc = al.getGapCharacter();
-    Object[] alandhidden = input.getAlignmentAndHiddenColumns(gc);
-    HiddenColumns nview = (HiddenColumns) alandhidden[1];
-    SequenceI origseq = ((SequenceI[]) alandhidden[0])[profsqpos];
-    nview.propagateInsertions(profileseq, al, origseq);
-    return nview;
-  }
-
-  /**
-   * 
-   * @param profileseq
-   *          sequence in al which corresponds to origseq
-   * @param al
-   *          alignment which is to have gaps inserted into it
-   * @param origseq
-   *          sequence corresponding to profileseq which defines gap map for
-   *          modifying al
-   */
-  private void propagateInsertions(SequenceI profileseq, AlignmentI al,
-          SequenceI origseq)
-  {
-    try
-    {
-      LOCK.writeLock().lock();
-
-      char gc = al.getGapCharacter();
-
-      // take the set of hidden columns, and the set of gaps in origseq,
-      // and remove all the hidden gaps from hiddenColumns
-
-      // first get the non-gaps as a Bitset
-      // then calculate hidden ^ not(gap)
-      BitSet gaps = origseq.gapBitset();
-      this.andNot(gaps);
-
-      // for each sequence in the alignment, except the profile sequence,
-      // insert gaps corresponding to each hidden region but where each hidden
-      // column region is shifted backwards by the number of preceding visible
-      // gaps update hidden columns at the same time
-      List<int[]> newhidden = new ArrayList<>();
-
-      int numGapsBefore = 0;
-      int gapPosition = 0;
-      for (int[] region : hiddenColumns)
-      {
-        // get region coordinates accounting for gaps
-        // we can rely on gaps not being *in* hidden regions because we already
-        // removed those
-        while (gapPosition < region[0])
-        {
-          gapPosition++;
-          if (gaps.get(gapPosition))
-          {
-            numGapsBefore++;
-          }
-        }
-
-        int left = region[0] - numGapsBefore;
-        int right = region[1] - numGapsBefore;
-        newhidden.add(new int[] { left, right });
-
-        // make a string with number of gaps = length of hidden region
-        StringBuilder sb = new StringBuilder();
-        for (int s = 0; s < right - left + 1; s++)
-        {
-          sb.append(gc);
-        }
-        padGaps(sb, left, profileseq, al);
-
-      }
-      hiddenColumns = newhidden;
-      cursor.resetCursor(hiddenColumns);
-      numColumns = 0;
-    } finally
-    {
-      LOCK.writeLock().unlock();
-    }
-  }
-
-  /**
-   * Pad gaps in all sequences in alignment except profileseq
-   * 
-   * @param sb
-   *          gap string to insert
-   * @param left
-   *          position to insert at
-   * @param profileseq
-   *          sequence not to pad
-   * @param al
-   *          alignment to pad sequences in
-   */
-  private void padGaps(StringBuilder sb, int pos, SequenceI profileseq,
-          AlignmentI al)
-  {
-    // loop over the sequences and pad with gaps where required
-    for (int s = 0, ns = al.getHeight(); s < ns; s++)
-    {
-      SequenceI sqobj = al.getSequenceAt(s);
-      if (sqobj != profileseq)
-      {
-        String sq = al.getSequenceAt(s).getSequenceAsString();
-        if (sq.length() <= pos)
-        {
-          // pad sequence
-          int diff = pos - sq.length() - 1;
-          if (diff > 0)
-          {
-            // pad gaps
-            sq = sq + sb;
-            while ((diff = pos - sq.length() - 1) > 0)
-            {
-              if (diff >= sb.length())
-              {
-                sq += sb.toString();
-              }
-              else
-              {
-                char[] buf = new char[diff];
-                sb.getChars(0, diff, buf, 0);
-                sq += buf.toString();
-              }
-            }
-          }
-          sq += sb.toString();
-        }
-        else
-        {
-          al.getSequenceAt(s).setSequence(
-                  sq.substring(0, pos) + sb.toString() + sq.substring(pos));
-        }
-      }
-    }
-  }
-
-  /*
-   * Methods which only need read access to the hidden columns collection. 
-   * These methods should use a readLock to prevent other threads changing
-   * the hidden columns collection while it is in use.
-   */
-
-  /**
    * Output regions data as a string. String is in the format:
    * reg0[0]<between>reg0[1]<delimiter>reg1[0]<between>reg1[1] ... regn[1]
    * 
@@ -605,7 +442,7 @@ public class HiddenColumns
     {
       LOCK.readLock().lock();
 
-      if (numColumns == 0)
+      if (numColumns == NUMCOLUMNS_RESET)
       {
         // numColumns is out of date, so recalculate
         int size = 0;
@@ -626,6 +463,17 @@ public class HiddenColumns
   }
 
   /**
+   * Reset numColumns so that it gets recalculated. Currently the code does not
+   * recalculate numColumns on hide/reveal as it requires a full sweep of the
+   * hidden columns collection / smarter updating. Placeholder here if later on
+   * a recalculation is added.
+   */
+  private void resetNumColumns()
+  {
+    numColumns = NUMCOLUMNS_RESET;
+  }
+
+  /**
    * Get the number of distinct hidden regions
    * 
    * @return number of regions
@@ -697,7 +545,8 @@ public class HiddenColumns
 
       if (!hiddenColumns.isEmpty())
       {
-        result += cursor.findRegionForVisColumn(column).getHiddenSoFar();
+        result += cursor.findRegionForColumn(column, true)
+                .getHiddenSoFar();
       }
 
       return result;
@@ -727,7 +576,7 @@ public class HiddenColumns
       if (!hiddenColumns.isEmpty())
       {
         HiddenCursorPosition cursorPos = cursor
-                .findRegionForColumn(hiddenColumn);
+                .findRegionForColumn(hiddenColumn, false);
         int index = cursorPos.getRegionIndex();
         int hiddenBeforeCol = cursorPos.getHiddenSoFar();
     
@@ -802,15 +651,22 @@ public class HiddenColumns
    * @return the index of the next hidden column, or alPos if there is no next
    *         hidden column
    */
-  public int getHiddenBoundaryRight(int alPos)
+  public int getNextHiddenBoundary(boolean left, int alPos)
   {
     try
     {
       LOCK.readLock().lock();
       if (!hiddenColumns.isEmpty())
       {
-        int index = cursor.findRegionForColumn(alPos).getRegionIndex();
-        if (index < hiddenColumns.size())
+        int index = cursor.findRegionForColumn(alPos, false)
+                .getRegionIndex();
+
+        if (left && index > 0)
+        {
+          int[] region = hiddenColumns.get(index - 1);
+          return region[1];
+        }
+        else if (!left && index < hiddenColumns.size())
         {
           int[] region = hiddenColumns.get(index);
           if (alPos < region[0])
@@ -835,38 +691,6 @@ public class HiddenColumns
   }
 
   /**
-   * This method returns the leftmost limit of a region of an alignment with
-   * hidden columns. In otherwords, the previous hidden column.
-   * 
-   * @param alPos
-   *          the absolute (visible) alignmentPosition to find the previous
-   *          hidden column for
-   */
-  public int getHiddenBoundaryLeft(int alPos)
-  {
-    try
-    {
-      LOCK.readLock().lock();
-
-      if (!hiddenColumns.isEmpty())
-      {
-        int index = cursor.findRegionForColumn(alPos).getRegionIndex();
-
-        if (index > 0)
-        {
-          int[] region = hiddenColumns.get(index - 1);
-          return region[1];
-        }
-      }
-      return alPos;
-    } finally
-    {
-      LOCK.readLock().unlock();
-    }
-  }
-
-
-  /**
    * Answers if a column in the alignment is visible
    * 
    * @param column
@@ -879,7 +703,8 @@ public class HiddenColumns
     {
       LOCK.readLock().lock();
 
-      int regionindex = cursor.findRegionForColumn(column).getRegionIndex();
+      int regionindex = cursor.findRegionForColumn(column, false)
+              .getRegionIndex();
       if (regionindex > -1 && regionindex < hiddenColumns.size())
       {
         int[] region = hiddenColumns.get(regionindex);
@@ -899,136 +724,6 @@ public class HiddenColumns
   }
 
   /**
-   * Get the visible sections of a set of sequences
-   * 
-   * @param start
-   *          sequence position to start from
-   * @param end
-   *          sequence position to end at
-   * @param seqs
-   *          an array of sequences
-   * @return an array of strings encoding the visible parts of each sequence
-   */
-  public String[] getVisibleSequenceStrings(int start, int end,
-          SequenceI[] seqs)
-  {
-    try
-    {
-      LOCK.readLock().lock();
-      int iSize = seqs.length;
-      String[] selections = new String[iSize];
-      if (!hiddenColumns.isEmpty())
-      {
-        for (int i = 0; i < iSize; i++)
-        {
-          StringBuilder visibleSeq = new StringBuilder();
-
-          Iterator<int[]> blocks = new VisibleContigsIterator(start,
-                  end + 1, hiddenColumns);
-
-          while (blocks.hasNext())
-          {
-            int[] block = blocks.next();
-            if (blocks.hasNext())
-            {
-              visibleSeq
-                      .append(seqs[i].getSequence(block[0], block[1] + 1));
-            }
-            else
-            {
-              visibleSeq
-                      .append(seqs[i].getSequence(block[0], block[1]));
-            }
-          }
-
-          selections[i] = visibleSeq.toString();
-        }
-      }
-      else
-      {
-        for (int i = 0; i < iSize; i++)
-        {
-          selections[i] = seqs[i].getSequenceAsString(start, end);
-        }
-      }
-
-      return selections;
-    } finally
-    {
-      LOCK.readLock().unlock();
-    }
-  }
-
-  /**
-   * Locate the first position visible for this sequence. If seq isn't visible
-   * then return the position of the left side of the hidden boundary region.
-   * 
-   * @param seq
-   *          sequence to find position for
-   * @return visible start position
-   */
-  public int locateVisibleStartOfSequence(SequenceI seq)
-  {
-    try
-    {
-      LOCK.readLock().lock();
-      int start = 0;
-
-      if (hiddenColumns.isEmpty())
-      {
-        return seq.findIndex(seq.getStart()) - 1;
-      }
-
-      // Simply walk along the sequence whilst watching for hidden column
-      // boundaries
-      Iterator<int[]> regions = hiddenColumns.iterator();
-      int hideStart = seq.getLength();
-      int hideEnd = -1;
-      int visPrev = 0;
-      int visNext = 0;
-      boolean foundStart = false;
-
-      // step through the non-gapped positions of the sequence
-      for (int i = seq.getStart(); i <= seq.getEnd() && (!foundStart); i++)
-      {
-        // get alignment position of this residue in the sequence
-        int p = seq.findIndex(i) - 1;
-
-        // update hidden region start/end
-        while (hideEnd < p && regions.hasNext())
-        {
-          int[] region = regions.next();
-          visPrev = visNext;
-          visNext += region[0] - visPrev;
-          hideStart = region[0];
-          hideEnd = region[1];
-        }
-        if (hideEnd < p)
-        {
-          hideStart = seq.getLength();
-        }
-        // update visible boundary for sequence
-        if (p < hideStart)
-        {
-          start = p;
-          foundStart = true;
-        }
-      }
-
-      if (foundStart)
-      {
-        return absoluteToVisibleColumn(start);
-      }
-      // otherwise, sequence was completely hidden
-      return visPrev;
-    } finally
-    {
-      LOCK.readLock().unlock();
-    }
-  }
-
-
-  /**
    * 
    * @return true if there are columns hidden
    */
@@ -1074,6 +769,7 @@ public class HiddenColumns
     {
       LOCK.readLock().lock();
       int hashCode = 1;
+
       for (int[] hidden : hiddenColumns)
       {
         hashCode = HASH_MULTIPLIER * hashCode + hidden[0];
@@ -1104,8 +800,8 @@ public class HiddenColumns
         lastSet = inserts.nextClearBit(firstSet);
         hideColumns(firstSet, lastSet - 1);
       }
-      cursor.resetCursor(hiddenColumns);
-      numColumns = 0;
+      cursor = new HiddenColumnsCursor(hiddenColumns);
+      resetNumColumns();
     } finally
     {
       LOCK.writeLock().unlock();
@@ -1154,7 +850,7 @@ public class HiddenColumns
       
       if (!hiddenColumns.isEmpty())
       {
-        HiddenCursorPosition pos = cursor.findRegionForColumn(start);
+        HiddenCursorPosition pos = cursor.findRegionForColumn(start, false);
         int index = pos.getRegionIndex();
         int startindex = index; // first index in hiddenColumns to remove
 
@@ -1171,7 +867,7 @@ public class HiddenColumns
           }
         }
 
-        pos = cursor.findRegionForColumn(end);
+        pos = cursor.findRegionForColumn(end, false);
         index = pos.getRegionIndex();
         int endindex = index - 1; // last index in hiddenColumns to remove
 
@@ -1188,8 +884,8 @@ public class HiddenColumns
         }
 
         hiddenColumns.subList(startindex, endindex + 1).clear();
-        cursor.resetCursor(hiddenColumns);
-        numColumns = 0;
+        cursor = new HiddenColumnsCursor(hiddenColumns);
+        resetNumColumns();
       }
     } finally
     {
@@ -1199,14 +895,14 @@ public class HiddenColumns
 
   /**
    * 
-   * @param inserts
+   * @param updates
    *          BitSet where hidden columns will be marked
    */
-  private void andNot(BitSet updates)
+  protected void andNot(BitSet updates)
   {
     try
     {
-      LOCK.readLock().lock();
+      LOCK.writeLock().lock();
 
       BitSet hiddenBitSet = new BitSet();
       for (int[] range : hiddenColumns)
@@ -1218,7 +914,7 @@ public class HiddenColumns
       hideColumns(hiddenBitSet);
     } finally
     {
-      LOCK.readLock().unlock();
+      LOCK.writeLock().unlock();
     }
   }
 
@@ -1234,42 +930,27 @@ public class HiddenColumns
     try
     {
       LOCK.readLock().lock();
-      int[] alignmentStartEnd = new int[] { 0, width - 1 };
-      int startPos = alignmentStartEnd[0];
-      int endPos = alignmentStartEnd[1];
 
-      int[] lowestRange = new int[] { -1, -1 };
-      int[] higestRange = new int[] { -1, -1 };
+      int firstVisible = 0;
+      int lastVisible = width - 1;
 
-      if (hiddenColumns.isEmpty())
+      if (!hiddenColumns.isEmpty())
       {
-        return new int[] { startPos, endPos };
-      }
+        // first visible col with index 0, convert to absolute index
+        firstVisible = visibleToAbsoluteColumn(0);
 
-      for (int[] range : hiddenColumns)
-      {
-        lowestRange = (range[0] <= startPos) ? range : lowestRange;
-        higestRange = (range[1] >= endPos) ? range : higestRange;
-      }
-
-      if (lowestRange[0] == -1) // includes (lowestRange[1] == -1)
-      {
-        startPos = alignmentStartEnd[0];
-      }
-      else
-      {
-        startPos = lowestRange[1] + 1;
+        // last visible column is either immediately to left of
+        // last hidden region, or is just the last column in the alignment
+        int[] lastregion = hiddenColumns.get(hiddenColumns.size() - 1);
+        if (lastregion[1] == width - 1)
+        {
+          // last region is at very end of alignment
+          // last visible column immediately precedes it
+          lastVisible = lastregion[0] - 1;
+        }
       }
+      return new int[] { firstVisible, lastVisible };
 
-      if (higestRange[0] == -1) // includes (higestRange[1] == -1)
-      {
-        endPos = alignmentStartEnd[1];
-      }
-      else
-      {
-        endPos = higestRange[0] - 1;
-      }
-      return new int[] { startPos, endPos };
     } finally
     {
       LOCK.readLock().unlock();
@@ -1296,7 +977,7 @@ public class HiddenColumns
       if (!hiddenColumns.isEmpty())
       {
         // look for a region ending just before adjres
-        int regionindex = cursor.findRegionForColumn(adjres - 1)
+        int regionindex = cursor.findRegionForColumn(adjres - 1, false)
                 .getRegionIndex();
         if (regionindex < hiddenColumns.size()
                 && hiddenColumns.get(regionindex)[1] == adjres - 1)
@@ -1378,7 +1059,7 @@ public class HiddenColumns
       // region we'll get the cursor pointing to the region before, which is
       // what we want
       HiddenCursorPosition pos = cursor
-              .findRegionForColumn(absoluteStart - 1);
+              .findRegionForColumn(absoluteStart - 1, false);
 
       return new BoundedStartRegionIterator(pos, start, end,
               hiddenColumns);