JAL-2759 Updated absoluteToVisibleColumn doc (prev findColumnPosition)

[jalview.git] / src / jalview / datamodel / HiddenColumns.java

diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java
index fa5d0a0..93791e4 100644 (file)
--- a/src/jalview/datamodel/HiddenColumns.java
+++ b/src/jalview/datamodel/HiddenColumns.java
@@ -188,10 +188,28 @@ public class HiddenColumns
         wasAlreadyLocked = true;
       }
 
+      int previndex = 0;
+      int prevHiddenCount = 0;
+      int regionindex = 0;
       if (hiddenColumns == null)
       {
         hiddenColumns = new ArrayList<>();
       }
+      else
+      {
+        // set up cursor reset values
+        HiddenCursorPosition cursorPos = cursor.findRegionForColumn(start);
+        regionindex = cursorPos.getRegionIndex();
+
+        if (regionindex > 0)
+        {
+          // get previous index and hidden count for updating the cursor later
+          previndex = regionindex - 1;
+          int[] prevRegion = hiddenColumns.get(previndex);
+          prevHiddenCount = cursorPos.getHiddenSoFar()
+                  - (prevRegion[1] - prevRegion[0] + 1);
+        }
+      }
 
       /*
        * new range follows everything else; check first to avoid looping over whole hiddenColumns collection
@@ -208,18 +226,23 @@ public class HiddenColumns
          * appropriate
          */
         boolean added = false;
-        for (int i = 0; !added && i < hiddenColumns.size(); i++)
+        if (regionindex > 0)
+        {
+          added = insertRangeAtRegion(regionindex - 1, start, end);
+        }
+        if (!added && regionindex < hiddenColumns.size())
         {
-          added = insertRangeAtRegion(i, start, end);
-        } // for
+          insertRangeAtRegion(regionindex, start, end);
+        }
       }
-      if (!wasAlreadyLocked)
-      {
-        cursor.resetCursor(hiddenColumns);
 
-        // reset the number of columns so they will be recounted
-        numColumns = 0;
-      }
+      // reset the cursor to just before our insertion point: this saves
+      // a lot of reprocessing in large alignments
+      cursor.resetCursor(hiddenColumns, previndex, prevHiddenCount);
+
+      // reset the number of columns so they will be recounted
+      numColumns = 0;
+
     } finally
     {
       if (!wasAlreadyLocked)
@@ -287,6 +310,9 @@ public class HiddenColumns
           break;
         }
         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();
       }
       added = true;
@@ -709,7 +735,7 @@ public class HiddenColumns
    *          int column index in alignment view (count from zero)
    * @return alignment column index for column
    */
-  public int adjustForHiddenColumns(int column)
+  public int visibleToAbsoluteColumn(int column)
   {
     try
     {
@@ -718,7 +744,7 @@ public class HiddenColumns
 
       if (hiddenColumns != null)
       {
-        result += cursor.getHiddenOffset(column).getHiddenSoFar();
+        result += cursor.findRegionForVisColumn(column).getHiddenSoFar();
       }
 
       return result;
@@ -731,13 +757,14 @@ public class HiddenColumns
   /**
    * Use this method to find out where a column will appear in the visible
    * alignment when hidden columns exist. If the column is not visible, then the
-   * left-most visible column will always be returned.
+   * index of the next visible column on the left will be returned (or 0 if
+   * there is no visible column on the left)
    * 
    * @param hiddenColumn
    *          the column index in the full alignment including hidden columns
    * @return the position of the column in the visible alignment
    */
-  public int findColumnPosition(int hiddenColumn)
+  public int absoluteToVisibleColumn(int hiddenColumn)
   {
     try
     {
@@ -803,7 +830,7 @@ public class HiddenColumns
       int distance = visibleDistance;
 
       // in case startColumn is in a hidden region, move it to the left
-      int start = adjustForHiddenColumns(findColumnPosition(startColumn));
+      int start = visibleToAbsoluteColumn(absoluteToVisibleColumn(startColumn));
 
       Iterator<int[]> it = new ReverseRegionsIterator(0, start,
               hiddenColumns);
@@ -842,6 +869,8 @@ public class HiddenColumns
    * @param alPos
    *          the absolute (visible) alignmentPosition to find the next hidden
    *          column for
+   * @return the index of the next hidden column, or alPos if there is no next
+   *         hidden column
    */
   public int getHiddenBoundaryRight(int alPos)
   {
@@ -1058,7 +1087,7 @@ public class HiddenColumns
 
       if (foundStart)
       {
-        return findColumnPosition(start);
+        return absoluteToVisibleColumn(start);
       }
       // otherwise, sequence was completely hidden
       return visPrev;
@@ -1191,6 +1220,9 @@ public class HiddenColumns
     try
     {
       LOCK.readLock().lock();
+
+      // we don't use getSize()>0 here because it has to iterate over
+      // the full hiddenColumns collection and so will be much slower
       return hiddenColumns != null && hiddenColumns.size() > 0;
     } finally
     {
@@ -1200,9 +1232,9 @@ public class HiddenColumns
 
   /**
    * 
-   * @return true if there are more than one set of columns hidden
+   * @return true if there is more than one hidden column region
    */
-  public boolean hasManyHiddenColumns()
+  public boolean hasMultiHiddenColumnRegions()
   {
     try
     {
@@ -1359,7 +1391,7 @@ public class HiddenColumns
     try
     {
       LOCK.readLock().lock();
-      int adjres = adjustForHiddenColumns(res);
+      int adjres = visibleToAbsoluteColumn(res);
 
       int[] reveal = null;
 
@@ -1396,7 +1428,7 @@ public class HiddenColumns
     try
     {
       LOCK.readLock().lock();
-      return new BoundedHiddenColsIterator(hiddenColumns);
+      return new HiddenColsIterator(hiddenColumns);
     } finally
     {
       LOCK.readLock().unlock();
@@ -1417,7 +1449,7 @@ public class HiddenColumns
     try
     {
       LOCK.readLock().lock();
-      return new BoundedHiddenColsIterator(start, end, hiddenColumns);
+      return new HiddenColsIterator(start, end, hiddenColumns);
     } finally
     {
       LOCK.readLock().unlock();
@@ -1440,7 +1472,7 @@ public class HiddenColumns
       LOCK.readLock().lock();
 
       // get absolute position of column in alignment
-      int absoluteStart = adjustForHiddenColumns(start);
+      int absoluteStart = visibleToAbsoluteColumn(start);
 
       // Get cursor position and supply it to the iterator:
       // Since we want visible region start, we look for a cursor for the
@@ -1498,8 +1530,8 @@ public class HiddenColumns
     int adjend = end;
     if (useVisibleCoords)
     {
-      adjstart = adjustForHiddenColumns(start);
-      adjend = adjustForHiddenColumns(end);
+      adjstart = visibleToAbsoluteColumn(start);
+      adjend = visibleToAbsoluteColumn(end);
     }
 
     try