X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumnsCursor.java;h=d6b6c10d0059c870af672ea7474d508fca1f7f61;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=32845049913e4406fcffe8e1c3111360b6bde8d1;hpb=f149fa7699eddc4968dc5a9fa35694abcc28b0cd;p=jalview.git diff --git a/src/jalview/datamodel/HiddenColumnsCursor.java b/src/jalview/datamodel/HiddenColumnsCursor.java index 3284504..d6b6c10 100644 --- a/src/jalview/datamodel/HiddenColumnsCursor.java +++ b/src/jalview/datamodel/HiddenColumnsCursor.java @@ -20,213 +20,193 @@ */ package jalview.datamodel; +import java.util.ArrayList; import java.util.List; -import java.util.concurrent.atomic.AtomicReference; public class HiddenColumnsCursor { // absolute position of first hidden column private int firstColumn; - private List hiddenColumns; + private List hiddenColumns = new ArrayList<>(); - // AtomicReference to hold the current region index and hidden column count - // Could be done with synchronisation but benchmarking shows this way is 2x - // faster - private final AtomicReference cursorPos = new AtomicReference<>( - new HiddenCursorPosition(0, 0, 0)); + private HiddenCursorPosition cursorPos = new HiddenCursorPosition(0, 0); protected HiddenColumnsCursor() { } - /** - * Reset the cursor with a new hidden columns collection. Calls to resetCursor - * should be made from within a writeLock in the HiddenColumns class - since - * changes to the hiddenColumns collection require a writeLock the lock should - * already exist. - * - * @param hiddenCols - */ - protected void resetCursor(List hiddenCols) + protected HiddenColumnsCursor(List hiddenCols) { - hiddenColumns = hiddenCols; - if ((hiddenCols != null) && (!hiddenCols.isEmpty())) - { - firstColumn = hiddenColumns.get(0)[0]; - HiddenCursorPosition oldpos = cursorPos.get(); - HiddenCursorPosition newpos = new HiddenCursorPosition(0, 0, 0); - cursorPos.compareAndSet(oldpos, newpos); - } + resetCursor(hiddenCols, 0, 0); + } + + protected HiddenColumnsCursor(List hiddenCols, int index, + int hiddencount) + { + resetCursor(hiddenCols, index, hiddencount); } /** - * Delete the region the cursor is currently at. Avoids having to reset the - * cursor just because we deleted a region. + * Reset the cursor with a new hidden columns collection, where we know in + * advance the index and hidden columns count of a particular location. * - * Calls to updateForDeletedRegion should be made from within a writeLock in - * the HiddenColumns class - since changes to the hiddenColumns collection - * require a writeLock the lock should already exist. - * * @param hiddenCols + * new hidden columns collection + * @param index + * cursor index to reset to + * @param hiddencount + * hidden columns count to reset to */ - protected void updateForDeletedRegion(List hiddenCols) + private void resetCursor(List hiddenCols, int index, + int hiddencount) { - - if ((hiddenCols != null) && (!hiddenCols.isEmpty())) + hiddenColumns = hiddenCols; + if (!hiddenCols.isEmpty()) { - // if there is a region to the right of the current region, - // nothing changes; otherwise - // we deleted the last region (index=hiddenCols.size()-1) - // or the index was at the end of the alignment (index=hiddenCols.size()) - HiddenCursorPosition oldpos = cursorPos.get(); - - int index = oldpos.getRegionIndex(); - if (index >= hiddenColumns.size() - 1) - { - // deleted last region, index is now end of alignment - index = hiddenCols.size(); - } - - // update the cursor position - HiddenCursorPosition newpos = new HiddenCursorPosition(index, - oldpos.getHiddenSoFar(), oldpos.getNumColumns()); - cursorPos.compareAndSet(oldpos, newpos); + firstColumn = hiddenColumns.get(0)[0]; + cursorPos = new HiddenCursorPosition(index, hiddencount); } - hiddenColumns = hiddenCols; } /** - * Get the index of the region that column is within (if column is hidden) or - * which is to the right of column (if column is visible). If no hidden - * columns are to the right, will return size of hiddenColumns. If hidden - * columns is empty returns -1. + * Get the cursor pointing to the hidden region that column is within (if + * column is hidden) or which is to the right of column (if column is + * visible). If no hidden columns are to the right, returns a cursor pointing + * to an imaginary hidden region beyond the end of the hidden columns + * collection (this ensures the count of previous hidden columns is correct). + * If hidden columns is empty returns null. * * @param column - * absolute position of a column in the alignment - * @return region index + * index of column in visible or absolute coordinates + * @param useVisible + * true if column is in visible coordinates, false if absolute + * @return cursor pointing to hidden region containing the column (if hidden) + * or to the right of the column (if visible) */ - protected HiddenCursorPosition findRegionForColumn(int column) + protected HiddenCursorPosition findRegionForColumn(int column, + boolean useVisible) { - if (hiddenColumns == null) + if (hiddenColumns.isEmpty()) { return null; } - HiddenCursorPosition oldpos = cursorPos.get(); - int index = oldpos.getRegionIndex(); - int hiddenCount = oldpos.getHiddenSoFar(); + // used to add in hiddenColumns offset when working with visible columns + int offset = (useVisible ? 1 : 0); - if (index == hiddenColumns.size()) - { - // went past the end of hiddenColumns collection last time - index--; - int[] region = hiddenColumns.get(index); - hiddenCount -= region[1] - region[0] + 1; - } + HiddenCursorPosition pos = cursorPos; + int index = pos.getRegionIndex(); + int hiddenCount = pos.getHiddenSoFar(); - if ((hiddenColumns.get(index)[0] <= column) - && hiddenColumns.get(index)[1] >= column) - { - // column is in the current region - // we hit the jackpot - // don't need to move index - } - else if (column < firstColumn) + if (column < firstColumn) { - index = 0; - hiddenCount = 0; + pos = new HiddenCursorPosition(0, 0); } + // column is after current region - else if (column > hiddenColumns.get(index)[1]) // includes if column > - // lastColumn + else if ((index < hiddenColumns.size()) + && (hiddenColumns.get(index)[0] <= column + + offset * hiddenCount)) { // iterate from where we are now, if we're lucky we'll be close by // (but still better than iterating from 0) // stop when we find the region *before* column // i.e. the next region starts after column or if not, ends after column - while ((index < hiddenColumns.size()) - && (column > hiddenColumns.get(index)[1])) - { - int[] region = hiddenColumns.get(index); - hiddenCount += region[1] - region[0] + 1; - index++; - } + pos = searchForward(pos, column, useVisible); } // column is before current region - else if (column < hiddenColumns.get(index)[0]) + else { - // column is before or in the previous region - if ((index > 0) && (hiddenColumns.get(index - 1)[1] >= column)) - { - while ((index > 0) && (hiddenColumns.get(index - 1)[1] >= column)) - { - index--; - int[] region = hiddenColumns.get(index); - hiddenCount -= region[1] - region[0] + 1; - } - } + pos = searchBackward(pos, column, useVisible); } - HiddenCursorPosition newpos = new HiddenCursorPosition(index, - hiddenCount, oldpos.getNumColumns()); - cursorPos.compareAndSet(oldpos, newpos); - return newpos; + cursorPos = pos; + return pos; } /** - * Get the number of hidden columns in regions before column i.e. excludes - * hidden columns in the region column is in, if any + * Search forwards through the hidden columns collection to find the hidden + * region immediately before a column * + * @param pos + * current position * @param column - * index of column in visible alignment - * @return + * column to locate + * @param useVisible + * whether using visible or absolute coordinates + * @return position of region before column */ - protected HiddenCursorPosition getHiddenOffset(int column) + private HiddenCursorPosition searchForward(HiddenCursorPosition pos, + int column, boolean useVisible) { - if (hiddenColumns == null) + HiddenCursorPosition p = pos; + if (useVisible) { - return null; - } - - HiddenCursorPosition oldpos = cursorPos.get(); - int index = oldpos.getRegionIndex(); - int hiddenCount = oldpos.getHiddenSoFar(); - - if (column < firstColumn) - { - index = 0; - hiddenCount = 0; - } - else if ((index < hiddenColumns.size()) - && (hiddenColumns.get(index)[0] <= column + hiddenCount)) - { - // iterate from where we are now, if we're lucky we'll be close by - // (but still better than iterating from 0) - while ((index < hiddenColumns.size()) - && (hiddenColumns.get(index)[0] <= column + hiddenCount)) + while ((p.getRegionIndex() < hiddenColumns.size()) + && hiddenColumns.get(p.getRegionIndex())[0] <= column + + p.getHiddenSoFar()) { - int[] region = hiddenColumns.get(index); - hiddenCount += region[1] - region[0] + 1; - index++; + p = stepForward(p); } } else { - while ((index > 0) - && (hiddenColumns.get(index - 1)[1] >= column + hiddenCount)) + while ((p.getRegionIndex() < hiddenColumns.size()) + && hiddenColumns.get(p.getRegionIndex())[1] < column) { - index--; - int[] region = hiddenColumns.get(index); - hiddenCount -= region[1] - region[0] + 1; + p = stepForward(p); } - } + return p; + } + + /** + * Move to the next (rightwards) hidden region after a given cursor position + * + * @param p + * current position of cursor + * @return new position of cursor at next region + */ + private HiddenCursorPosition stepForward(HiddenCursorPosition p) + { + int[] region = hiddenColumns.get(p.getRegionIndex()); - HiddenCursorPosition newpos = new HiddenCursorPosition(index, - hiddenCount, oldpos.getNumColumns()); - cursorPos.compareAndSet(oldpos, newpos); - return newpos; + // increment the index, and add this region's hidden columns to the hidden + // column count + return new HiddenCursorPosition(p.getRegionIndex() + 1, + p.getHiddenSoFar() + region[1] - region[0] + 1); } + + /** + * Search backwards through the hidden columns collection to find the hidden + * region immediately before (left of) a given column + * + * @param pos + * current position + * @param column + * column to locate + * @param useVisible + * whether using visible or absolute coordinates + * @return position of region immediately to left of column + */ + private HiddenCursorPosition searchBackward(HiddenCursorPosition p, + int column, boolean useVisible) + { + int i = p.getRegionIndex(); + int h = p.getHiddenSoFar(); + + // used to add in hiddenColumns offset when working with visible columns + int offset = (useVisible ? 1 : 0); + + while ((i > 0) && (hiddenColumns.get(i - 1)[1] >= column + offset * h)) + { + i--; + int[] region = hiddenColumns.get(i); + h -= region[1] - region[0] + 1; + } + return new HiddenCursorPosition(i, h); + } + }