X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=89fb1ab21b2246e1dd61aaf3fec356e731ef2672;hb=HEAD;hp=82e25b9e2bf58524c7c51d53b3c579eff5efe881;hpb=e2c3b3602486cee3f85dd8dfc7856a5ce6701669;p=jalview.git diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java index 82e25b9..89fb1ab 100644 --- a/src/jalview/datamodel/HiddenColumns.java +++ b/src/jalview/datamodel/HiddenColumns.java @@ -20,16 +20,48 @@ */ package jalview.datamodel; -import jalview.util.Comparison; - import java.util.ArrayList; +import java.util.Arrays; import java.util.BitSet; -import java.util.Collections; import java.util.Iterator; import java.util.List; -import java.util.Vector; import java.util.concurrent.locks.ReentrantReadWriteLock; +/** + * This class manages the collection of hidden columns associated with an + * alignment. To iterate over the collection, or over visible columns/regions, + * use an iterator obtained from one of: + * + * - getBoundedIterator: iterates over the hidden regions, within some bounds, + * returning *absolute* positions + * + * - getBoundedStartIterator: iterates over the start positions of hidden + * regions, within some bounds, returning *visible* positions + * + * - getVisContigsIterator: iterates over visible regions in a range, returning + * *absolute* positions + * + * - getVisibleColsIterator: iterates over the visible *columns* + * + * For performance reasons, provide bounds where possible. Note that column + * 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; @@ -37,10 +69,22 @@ public class HiddenColumns private static final ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock(); /* + * Cursor which tracks the last used hidden columns region, and the number + * of hidden columns up to (but not including) that region. + */ + private HiddenColumnsCursor cursor = new HiddenColumnsCursor(); + + /* + * cache of the number of hidden columns: must be kept up to date by methods + * which add or remove hidden columns + */ + private int numColumns = 0; + + /* * list of hidden column [start, end] ranges; the list is maintained in * ascending start column order */ - private ArrayList hiddenColumns; + private List hiddenColumns = new ArrayList<>(); /** * Constructor @@ -53,23 +97,11 @@ public class HiddenColumns * Copy constructor * * @param copy + * the HiddenColumns object to copy from */ public HiddenColumns(HiddenColumns copy) { - try - { - LOCK.writeLock().lock(); - if (copy != null) - { - if (copy.hiddenColumns != null) - { - hiddenColumns = copy.copyHiddenRegionsToArrayList(0); - } - } - } finally - { - LOCK.writeLock().unlock(); - } + this(copy, Integer.MIN_VALUE, Integer.MAX_VALUE, 0); } /** @@ -94,8 +126,8 @@ public class HiddenColumns LOCK.writeLock().lock(); if (copy != null) { - hiddenColumns = new ArrayList<>(); - Iterator it = copy.getBoundedIterator(start, end, true); + numColumns = 0; + Iterator it = copy.getBoundedIterator(start, end); while (it.hasNext()) { int[] region = it.next(); @@ -103,12 +135,226 @@ public class HiddenColumns // all overlapping regions and we need contained regions if (region[0] >= start && region[1] <= end) { - hiddenColumns.add( - new int[] - { region[0] - offset, region[1] - offset }); + hiddenColumns + .add(new int[] + { region[0] - offset, region[1] - offset }); + numColumns += region[1] - region[0] + 1; } } + cursor = new HiddenColumnsCursor(hiddenColumns); + } + } finally + { + LOCK.writeLock().unlock(); + } + } + + /** + * Adds the specified column range to the hidden columns collection + * + * @param start + * start of range to add (absolute position in alignment) + * @param end + * end of range to add (absolute position in alignment) + */ + public void hideColumns(int start, int end) + { + try + { + LOCK.writeLock().lock(); + + int previndex = 0; + int prevHiddenCount = 0; + int regionindex = 0; + if (!hiddenColumns.isEmpty()) + { + // set up cursor reset values + HiddenCursorPosition cursorPos = cursor.findRegionForColumn(start, + false); + 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 + if (hiddenColumns.isEmpty() + || start > hiddenColumns.get(hiddenColumns.size() - 1)[1]) + { + hiddenColumns.add(new int[] { start, end }); + numColumns += end - start + 1; + } + else + { + /* + * traverse existing hidden ranges and insert / amend / append as + * appropriate + */ + boolean added = false; + if (regionindex > 0) + { + added = insertRangeAtRegion(regionindex - 1, start, end); + } + if (!added && regionindex < hiddenColumns.size()) + { + insertRangeAtRegion(regionindex, start, end); + } + } + + // reset the cursor to just before our insertion point: this saves + // a lot of reprocessing in large alignments + cursor = new HiddenColumnsCursor(hiddenColumns, previndex, + prevHiddenCount); + } finally + { + LOCK.writeLock().unlock(); + } + } + + /** + * Insert [start, range] at the region at index i in hiddenColumns, if + * feasible + * + * @param i + * index to insert at + * @param start + * start of range to insert + * @param end + * end of range to insert + * @return true if range was successfully inserted + */ + private boolean insertRangeAtRegion(int i, int start, int end) + { + boolean added = false; + + int[] region = hiddenColumns.get(i); + if (end < region[0] - 1) + { + /* + * insert discontiguous preceding range + */ + hiddenColumns.add(i, new int[] { start, end }); + numColumns += end - start + 1; + added = true; + } + else if (end <= region[1]) + { + /* + * new range overlaps existing, or is contiguous preceding it - adjust + * start column + */ + int oldstart = region[0]; + region[0] = Math.min(region[0], start); + numColumns += oldstart - region[0]; // new columns are between old and + // adjusted starts + added = true; + } + else if (start <= region[1] + 1) + { + /* + * new range overlaps existing, or is contiguous following it - adjust + * start and end columns + */ + insertRangeAtOverlap(i, start, end, region); + added = true; + } + return added; + } + + /** + * Insert a range whose start position overlaps an existing region and/or is + * contiguous to the right of the region + * + * @param i + * index to insert at + * @param start + * start of range to insert + * @param end + * end of range to insert + * @param region + * the overlapped/continued region + */ + private void insertRangeAtOverlap(int i, int start, int end, int[] region) + { + int oldstart = region[0]; + int oldend = region[1]; + region[0] = Math.min(region[0], start); + region[1] = Math.max(region[1], end); + + numColumns += oldstart - region[0]; + + /* + * also update or remove any subsequent ranges + * that are overlapped + */ + int endi = i; + while (endi < hiddenColumns.size() - 1) + { + int[] nextRegion = hiddenColumns.get(endi + 1); + if (nextRegion[0] > end + 1) + { + /* + * gap to next hidden range - no more to update + */ + break; + } + numColumns -= nextRegion[1] - nextRegion[0] + 1; + region[1] = Math.max(nextRegion[1], end); + endi++; + } + numColumns += region[1] - oldend; + hiddenColumns.subList(i + 1, endi + 1).clear(); + } + + /** + * hide a list of ranges + * + * @param ranges + */ + public void hideList(List ranges) + { + try + { + LOCK.writeLock().lock(); + for (int[] r : ranges) + { + hideColumns(r[0], r[1]); + } + cursor = new HiddenColumnsCursor(hiddenColumns); + + } finally + { + LOCK.writeLock().unlock(); + } + } + + /** + * Unhides, and adds to the selection list, all hidden columns + */ + public void revealAllHiddenColumns(ColumnSelection sel) + { + try + { + LOCK.writeLock().lock(); + + for (int[] region : hiddenColumns) + { + for (int j = region[0]; j < region[1] + 1; j++) + { + sel.addElement(j); + } } + hiddenColumns.clear(); + cursor = new HiddenColumnsCursor(hiddenColumns); + numColumns = 0; + } finally { LOCK.writeLock().unlock(); @@ -116,16 +362,46 @@ public class HiddenColumns } /** - * This method is used to return all the HiddenColumn regions and is intended - * to remain private. External callers which need a copy of the regions can - * call getHiddenColumnsCopyAsList. + * Reveals, and marks as selected, the hidden column range with the given + * start column * - * @return empty list or List of hidden column intervals + * @param start + * the start column to look for + * @param sel + * the column selection to add the hidden column range to */ - private List getHiddenRegions() + public void revealHiddenColumns(int start, ColumnSelection sel) { - return hiddenColumns == null ? Collections. emptyList() - : hiddenColumns; + try + { + LOCK.writeLock().lock(); + + if (!hiddenColumns.isEmpty()) + { + int regionIndex = cursor.findRegionForColumn(start, false) + .getRegionIndex(); + + if (regionIndex != -1 && regionIndex != hiddenColumns.size()) + { + // regionIndex is the region which either contains start + // or lies to the right of start + int[] region = hiddenColumns.get(regionIndex); + if (start == region[0]) + { + for (int j = region[0]; j < region[1] + 1; j++) + { + sel.addElement(j); + } + int colsToRemove = region[1] - region[0] + 1; + hiddenColumns.remove(regionIndex); + numColumns -= colsToRemove; + } + } + } + } finally + { + LOCK.writeLock().unlock(); + } } /** @@ -144,16 +420,22 @@ public class HiddenColumns { LOCK.readLock().lock(); StringBuilder regionBuilder = new StringBuilder(); - if (hiddenColumns != null) + + boolean first = true; + for (int[] range : hiddenColumns) { - for (int[] range : hiddenColumns) + if (!first) { - regionBuilder.append(delimiter).append(range[0]).append(between) - .append(range[1]); + regionBuilder.append(delimiter); } + else + { + first = false; + } + regionBuilder.append(range[0]).append(between).append(range[1]); - regionBuilder.deleteCharAt(0); } + return regionBuilder.toString(); } finally { @@ -168,22 +450,7 @@ public class HiddenColumns */ public int getSize() { - try - { - LOCK.readLock().lock(); - int size = 0; - if (hasHiddenColumns()) - { - for (int[] range : hiddenColumns) - { - size += range[1] - range[0] + 1; - } - } - return size; - } finally - { - LOCK.readLock().unlock(); - } + return numColumns; } /** @@ -196,18 +463,17 @@ public class HiddenColumns try { LOCK.readLock().lock(); - int num = 0; - if (hasHiddenColumns()) - { - num = hiddenColumns.size(); - } - return num; + return hiddenColumns.size(); } finally { LOCK.readLock().unlock(); } } + /** + * Answers true if obj is an instance of HiddenColumns, and holds the same + * array of start-end column ranges as this, else answers false + */ @Override public boolean equals(Object obj) { @@ -224,25 +490,23 @@ public class HiddenColumns /* * check hidden columns are either both null, or match */ - if (this.hiddenColumns == null) - { - return (that.hiddenColumns == null); - } - if (that.hiddenColumns == null - || that.hiddenColumns.size() != this.hiddenColumns.size()) + + if (that.hiddenColumns.size() != this.hiddenColumns.size()) { return false; } - int i = 0; - for (int[] thisRange : hiddenColumns) + + Iterator it = this.iterator(); + Iterator thatit = that.iterator(); + while (it.hasNext()) { - int[] thatRange = that.hiddenColumns.get(i++); - if (thisRange[0] != thatRange[0] || thisRange[1] != thatRange[1]) + if (!(Arrays.equals(it.next(), thatit.next()))) { return false; } } return true; + } finally { LOCK.readLock().unlock(); @@ -256,23 +520,18 @@ 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 { LOCK.readLock().lock(); int result = column; - if (hiddenColumns != null) + + if (!hiddenColumns.isEmpty()) { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.get(i); - if (result >= region[0]) - { - result += region[1] - region[0] + 1; - } - } + result += cursor.findRegionForColumn(column, true).getHiddenSoFar(); } + return result; } finally { @@ -283,54 +542,52 @@ 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 { LOCK.readLock().lock(); int result = hiddenColumn; - if (hiddenColumns != null) - { - int index = 0; - int[] region; - do - { - region = hiddenColumns.get(index++); - if (hiddenColumn > region[1]) - { - result -= region[1] + 1 - region[0]; - } - } while ((hiddenColumn > region[1]) - && (index < hiddenColumns.size())); - if (hiddenColumn >= region[0] && hiddenColumn <= region[1]) + if (!hiddenColumns.isEmpty()) + { + HiddenCursorPosition cursorPos = cursor + .findRegionForColumn(hiddenColumn, false); + int index = cursorPos.getRegionIndex(); + int hiddenBeforeCol = cursorPos.getHiddenSoFar(); + + // just subtract hidden cols count - this works fine if column is + // visible + result = hiddenColumn - hiddenBeforeCol; + + // now check in case column is hidden - it will be in the returned + // hidden region + if (index < hiddenColumns.size()) { - // Here the hidden column is within a region, so - // we want to return the position of region[0]-1, adjusted for any - // earlier hidden columns. - // Calculate the difference between the actual hidden col position - // and region[0]-1, and then subtract from result to convert result - // from - // the adjusted hiddenColumn value to the adjusted region[0]-1 value - - // However, if the region begins at 0 we cannot return region[0]-1 - // just return 0 - if (region[0] == 0) - { - return 0; - } - else + int[] region = hiddenColumns.get(index); + if (hiddenColumn >= region[0] && hiddenColumn <= region[1]) { - return result - (hiddenColumn - region[0] + 1); + // actually col is hidden, return region[0]-1 + // unless region[0]==0 in which case return 0 + if (region[0] == 0) + { + result = 0; + } + else + { + result = region[0] - 1 - hiddenBeforeCol; + } } } } + return result; // return the shifted position after removing hidden // columns. } finally @@ -341,119 +598,75 @@ public class HiddenColumns /** * Find the visible column which is a given visible number of columns to the - * left of another visible column. i.e. for a startColumn x, the column which - * is distance 1 away will be column x-1. + * left (negative visibleDistance) or right (positive visibleDistance) of + * startColumn. If startColumn is not visible, we use the visible column at + * the left boundary of the hidden region containing startColumn. * * @param visibleDistance - * the number of visible columns to offset by + * the number of visible columns to offset by (left offset = negative + * value; right offset = positive value) * @param startColumn - * the column to start from - * @return the position of the column in the visible alignment + * the position of the column to start from (absolute position) + * @return the position of the column which is away + * (absolute position) */ - public int subtractVisibleColumns(int visibleDistance, int startColumn) + public int offsetByVisibleColumns(int visibleDistance, int startColumn) { try { - LOCK.readLock().lock(); - int distance = visibleDistance; - - // in case startColumn is in a hidden region, move it to the left - int start = adjustForHiddenColumns(findColumnPosition(startColumn)); - - // get index of hidden region to left of start - int index = getHiddenIndexLeft(start); - if (index == -1) - { - // no hidden regions to left of startColumn - return start - distance; - } - - // walk backwards through the alignment subtracting the counts of visible - // columns from distance - int[] region; - int gap = 0; - int nextstart = start; - - while ((index > -1) && (distance - gap > 0)) - { - // subtract the gap to right of region from distance - distance -= gap; - start = nextstart; + int start = absoluteToVisibleColumn(startColumn); + return visibleToAbsoluteColumn(start + visibleDistance); - // calculate the next gap - region = hiddenColumns.get(index); - gap = start - region[1]; - - // set start to just to left of current region - nextstart = region[0] - 1; - index--; - } - - if (distance - gap > 0) - { - // fell out of loop because there are no more hidden regions - distance -= gap; - return nextstart - distance; - } - return start - distance; } finally { LOCK.readLock().unlock(); } - } /** - * Use this method to determine the set of hiddenRegion start positions - * between absolute position and absolute position - * - * @param start - * absolute residue to start from - * @param end - * absolute residue to end at + * This method returns the rightmost limit of a region of an alignment with + * hidden columns. In otherwords, the next hidden column. * - * @return list of column numbers in *visible* view where hidden regions start + * @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 List findHiddenRegionPositions(int start, int end) + public int getNextHiddenBoundary(boolean left, int alPos) { try { LOCK.readLock().lock(); - List positions = null; - - if (hiddenColumns != null) + if (!hiddenColumns.isEmpty()) { - positions = new ArrayList<>(hiddenColumns.size()); + int index = cursor.findRegionForColumn(alPos, false) + .getRegionIndex(); - // navigate to start, keeping count of hidden columns - int i = 0; - int hiddenSoFar = 0; - while ((i < hiddenColumns.size()) - && (hiddenColumns.get(i)[0] < start)) + if (left && index > 0) { - int[] region = hiddenColumns.get(i); - hiddenSoFar += region[1] - region[0] + 1; - i++; + int[] region = hiddenColumns.get(index - 1); + return region[1]; } - - // iterate from start to end, adding start positions of each - // hidden region. Positions are visible columns count, not absolute - while (i < hiddenColumns.size() - && (hiddenColumns.get(i)[0] < end)) + else if (!left && index < hiddenColumns.size()) { - int[] region = hiddenColumns.get(i); - positions.add(region[0] - hiddenSoFar); - hiddenSoFar += region[1] - region[0] + 1; - i++; + int[] region = hiddenColumns.get(index); + if (alPos < region[0]) + { + return region[0]; + } + else if ((alPos <= region[1]) + && (index + 1 < hiddenColumns.size())) + { + // alPos is within a hidden region, return the next one + // if there is one + region = hiddenColumns.get(index + 1); + return region[0]; + } } } - else - { - positions = new ArrayList<>(); - } - - return positions; + return alPos; } finally { LOCK.readLock().unlock(); @@ -461,69 +674,54 @@ public class HiddenColumns } /** - * This method returns the rightmost limit of a region of an alignment with - * hidden columns. In otherwords, the next hidden column. + * Answers if a column in the alignment is visible * - * @param index - * int + * @param column + * absolute position of column in the alignment + * @return true if column is visible */ - public int getHiddenBoundaryRight(int alPos) + public boolean isVisible(int column) { try { LOCK.readLock().lock(); - if (hiddenColumns != null) + + if (!hiddenColumns.isEmpty()) { - int index = 0; - do + int regionindex = cursor.findRegionForColumn(column, false) + .getRegionIndex(); + if (regionindex > -1 && regionindex < hiddenColumns.size()) { - int[] region = hiddenColumns.get(index); - if (alPos < region[0]) + int[] region = hiddenColumns.get(regionindex); + // already know that column <= region[1] as cursor returns containing + // region or region to right + if (column >= region[0]) { - return region[0]; + return false; } - - index++; - } while (index < hiddenColumns.size()); + } } + return true; - return alPos; } finally { LOCK.readLock().unlock(); } - } /** - * This method returns the leftmost limit of a region of an alignment with - * hidden columns. In otherwords, the previous hidden column. * - * @param index - * int + * @return true if there are columns hidden */ - public int getHiddenBoundaryLeft(int alPos) + public boolean hasHiddenColumns() { try { LOCK.readLock().lock(); - if (hiddenColumns != null) - { - int index = hiddenColumns.size() - 1; - do - { - int[] region = hiddenColumns.get(index); - if (alPos > region[1]) - { - return region[1]; - } - - index--; - } while (index > -1); - } - - return alPos; + // 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.isEmpty()); } finally { LOCK.readLock().unlock(); @@ -531,422 +729,232 @@ public class HiddenColumns } /** - * This method returns the index of the hidden region to the left of a column - * position. If the column is in a hidden region it returns the index of the - * region to the left. If there is no hidden region to the left it returns -1. * - * @param pos - * int + * @return true if there is more than one hidden column region */ - private int getHiddenIndexLeft(int pos) + public boolean hasMultiHiddenColumnRegions() { try { - LOCK.readLock().lock(); - if (hiddenColumns != null) - { - int index = hiddenColumns.size() - 1; - do - { - int[] region = hiddenColumns.get(index); - if (pos > region[1]) - { - return index; - } - - index--; - } while (index > -1); - } - - return -1; + return !hiddenColumns.isEmpty() && hiddenColumns.size() > 1; } finally { LOCK.readLock().unlock(); } - } /** - * Adds the specified column range to the hidden columns - * - * @param start - * @param end + * Returns a hashCode built from hidden column ranges */ - public void hideColumns(int start, int end) + @Override + public int hashCode() { - 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; - } - - if (hiddenColumns == null) - { - hiddenColumns = new ArrayList<>(); - } + LOCK.readLock().lock(); + int hashCode = 1; - /* - * traverse existing hidden ranges and insert / amend / append as - * appropriate - */ - for (int i = 0; i < hiddenColumns.size(); i++) + for (int[] hidden : hiddenColumns) { - int[] region = hiddenColumns.get(i); - - if (end < region[0] - 1) - { - /* - * insert discontiguous preceding range - */ - hiddenColumns.add(i, new int[] { start, end }); - return; - } - - if (end <= region[1]) - { - /* - * new range overlaps existing, or is contiguous preceding it - adjust - * start column - */ - region[0] = Math.min(region[0], start); - return; - } - - if (start <= region[1] + 1) - { - /* - * new range overlaps existing, or is contiguous following it - adjust - * start and end columns - */ - region[0] = Math.min(region[0], start); - region[1] = Math.max(region[1], end); - - /* - * also update or remove any subsequent ranges - * that are overlapped - */ - while (i < hiddenColumns.size() - 1) - { - int[] nextRegion = hiddenColumns.get(i + 1); - if (nextRegion[0] > end + 1) - { - /* - * gap to next hidden range - no more to update - */ - break; - } - region[1] = Math.max(nextRegion[1], end); - hiddenColumns.remove(i + 1); - } - return; - } + hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; + hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; } - - /* - * remaining case is that the new range follows everything else - */ - hiddenColumns.add(new int[] { start, end }); + return hashCode; } finally { - if (!wasAlreadyLocked) - { - LOCK.writeLock().unlock(); - } + LOCK.readLock().unlock(); } } - public boolean isVisible(int column) + /** + * Hide columns corresponding to the marked bits + * + * @param inserts + * - columns mapped to bits starting from zero + */ + public void hideColumns(BitSet inserts) + { + hideColumns(inserts, 0, inserts.length() - 1); + } + + /** + * Hide columns corresponding to the marked bits, within the range + * [start,end]. Entries in tohide which are outside [start,end] are ignored. + * + * @param tohide + * columns mapped to bits starting from zero + * @param start + * start of range to hide columns within + * @param end + * end of range to hide columns within + */ + private void hideColumns(BitSet tohide, int start, int end) { try { - LOCK.readLock().lock(); - - if (hiddenColumns != null) + LOCK.writeLock().lock(); + for (int firstSet = tohide + .nextSetBit(start), lastSet = start; firstSet >= start + && lastSet <= end; firstSet = tohide + .nextSetBit(lastSet)) { - for (int[] region : hiddenColumns) + lastSet = tohide.nextClearBit(firstSet); + if (lastSet <= end) { - if (column >= region[0] && column <= region[1]) - { - return false; - } + hideColumns(firstSet, lastSet - 1); + } + else if (firstSet <= end) + { + hideColumns(firstSet, end); } } - - return true; + cursor = new HiddenColumnsCursor(hiddenColumns); } finally { - LOCK.readLock().unlock(); - } - } - - private ArrayList copyHiddenRegionsToArrayList(int startIndex) - { - int size = 0; - if (hiddenColumns != null) - { - size = hiddenColumns.size(); - } - ArrayList copy = new ArrayList<>(size); - - for (int i = startIndex, j = size; i < j; i++) - { - int[] rh; - int[] cp; - rh = hiddenColumns.get(i); - if (rh != null) - { - cp = new int[rh.length]; - System.arraycopy(rh, 0, cp, 0, rh.length); - copy.add(cp); - } + LOCK.writeLock().unlock(); } - - return copy; } /** - * Returns a copy of the vector of hidden regions, as an ArrayList. Before - * using this method please consider if you really need access to the hidden - * regions - a new (or existing!) method on HiddenColumns might be more - * appropriate. + * Hide columns corresponding to the marked bits, within the range + * [start,end]. Entries in tohide which are outside [start,end] are ignored. + * NB Existing entries in [start,end] are cleared. * - * @return hidden regions as an ArrayList of [start,end] pairs + * @param tohide + * columns mapped to bits starting from zero + * @param start + * start of range to hide columns within + * @param end + * end of range to hide columns within */ - public ArrayList getHiddenColumnsCopy() + public void clearAndHideColumns(BitSet tohide, int start, int end) { - try - { - LOCK.readLock().lock(); - return copyHiddenRegionsToArrayList(0); - } finally - { - LOCK.readLock().unlock(); - } + clearHiddenColumnsInRange(start, end); + hideColumns(tohide, start, end); } /** - * return all visible segments between the given start and end boundaries + * Make all columns in the range [start,end] visible * * @param start - * (first column inclusive from 0) + * start of range to show columns * @param end - * (last column - not inclusive) - * @return List {[i_start, i_end], ..} where intervals lie in - * start<=i_start<=i_end getVisibleContigs(int start, int end) + private void clearHiddenColumnsInRange(int start, int end) { try { - LOCK.readLock().lock(); - List vcontigs = new ArrayList<>(); - if (hiddenColumns != null && hiddenColumns.size() > 0) + LOCK.writeLock().lock(); + + if (!hiddenColumns.isEmpty()) { - int vstart = start; - int hideStart; - int hideEnd; + HiddenCursorPosition pos = cursor.findRegionForColumn(start, false); + int index = pos.getRegionIndex(); - for (int[] region : hiddenColumns) + if (index != -1 && index != hiddenColumns.size()) { - hideStart = region[0]; - hideEnd = region[1]; - - // navigate to start - if (hideEnd < vstart) - { - continue; - } - if (hideStart > vstart) + // regionIndex is the region which either contains start + // or lies to the right of start + int[] region = hiddenColumns.get(index); + if (region[0] < start && region[1] >= start) { - int[] contig = new int[] { vstart, hideStart - 1 }; - vcontigs.add(contig); + // region contains start, truncate so that it ends just before start + numColumns -= region[1] - start + 1; + region[1] = start - 1; + index++; } - vstart = hideEnd + 1; - // exit if we're past the end - if (vstart >= end) + int endi = index; + while (endi < hiddenColumns.size()) { - break; + region = hiddenColumns.get(endi); + + if (region[1] > end) + { + if (region[0] <= end) + { + // region contains end, truncate so it starts just after end + numColumns -= end - region[0] + 1; + region[0] = end + 1; + } + break; + } + + numColumns -= region[1] - region[0] + 1; + endi++; } - } + hiddenColumns.subList(index, endi).clear(); - if (vstart < end) - { - int[] contig = new int[] { vstart, end - 1 }; - vcontigs.add(contig); } + + cursor = new HiddenColumnsCursor(hiddenColumns); } - else - { - int[] contig = new int[] { start, end - 1 }; - vcontigs.add(contig); - } - return vcontigs; } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } } - public String[] getVisibleSequenceStrings(int start, int end, - SequenceI[] seqs) + /** + * + * @param updates + * BitSet where hidden columns will be marked + */ + protected void andNot(BitSet updates) { try { - LOCK.readLock().lock(); - int iSize = seqs.length; - String[] selections = new String[iSize]; - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - for (int i = 0; i < iSize; i++) - { - StringBuffer visibleSeq = new StringBuffer(); - - int blockStart = start; - int blockEnd = end; - int hideStart; - int hideEnd; - - for (int[] region : hiddenColumns) - { - hideStart = region[0]; - hideEnd = region[1]; - - if (hideStart < start) - { - continue; - } - - blockStart = Math.min(blockStart, hideEnd + 1); - blockEnd = Math.min(blockEnd, hideStart); - - if (blockStart > blockEnd) - { - break; - } - - visibleSeq.append(seqs[i].getSequence(blockStart, blockEnd)); - - blockStart = hideEnd + 1; - blockEnd = end; - } - - if (end > blockStart) - { - visibleSeq.append(seqs[i].getSequence(blockStart, end)); - } + LOCK.writeLock().lock(); - selections[i] = visibleSeq.toString(); - } - } - else + BitSet hiddenBitSet = new BitSet(); + for (int[] range : hiddenColumns) { - for (int i = 0; i < iSize; i++) - { - selections[i] = seqs[i].getSequenceAsString(start, end); - } + hiddenBitSet.set(range[0], range[1] + 1); } - - return selections; + hiddenBitSet.andNot(updates); + hiddenColumns.clear(); + hideColumns(hiddenBitSet); } finally { - LOCK.readLock().unlock(); + LOCK.writeLock().unlock(); } } /** - * Locate the first and last position visible for this sequence. if seq isn't - * visible then return the position of the left and right of the hidden - * boundary region, and the corresponding alignment column indices for the - * extent of the sequence + * Calculate the visible start and end index of an alignment. * - * @param seq - * @return int[] { visible start, visible end, first seqpos, last seqpos, - * alignment index for seq start, alignment index for seq end } + * @param width + * full alignment width + * @return integer array where: int[0] = startIndex, and int[1] = endIndex */ - public int[] locateVisibleBoundsOfSequence(SequenceI seq) + public int[] getVisibleStartAndEndIndex(int width) { try { LOCK.readLock().lock(); - int fpos = seq.getStart(); - int lpos = seq.getEnd(); - int start = 0; - if (hiddenColumns == null || hiddenColumns.size() == 0) - { - int ifpos = seq.findIndex(fpos) - 1; - int ilpos = seq.findIndex(lpos) - 1; - return new int[] { ifpos, ifpos, ilpos }; - } + int firstVisible = 0; + int lastVisible = width - 1; - // Simply walk along the sequence whilst watching for hidden column - // boundaries - List regions = getHiddenRegions(); - int spos = fpos; - int rcount = 0; - int hideStart = seq.getLength(); - int hideEnd = -1; - int visPrev = 0; - int visNext = 0; - int firstP = -1; - int lastP = -1; - boolean foundStart = false; - for (int p = 0, pLen = seq.getLength(); spos <= seq.getEnd() - && p < pLen; p++) + if (!hiddenColumns.isEmpty()) { - if (!Comparison.isGap(seq.getCharAt(p))) + // first visible col with index 0, convert to absolute index + firstVisible = visibleToAbsoluteColumn(0); + + // 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) { - // keep track of first/last column - // containing sequence data regardless of visibility - if (firstP == -1) - { - firstP = p; - } - lastP = p; - // update hidden region start/end - while (hideEnd < p && rcount < regions.size()) - { - int[] region = regions.get(rcount++); - 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) - { - if (!foundStart) - { - fpos = spos; - start = p; - foundStart = true; - } - lpos = spos; - } - // look for next sequence position - spos++; + // last region is at very end of alignment + // last visible column immediately precedes it + lastVisible = lastregion[0] - 1; } } - if (foundStart) - { - return new int[] { findColumnPosition(start), firstP, lastP }; - } - // otherwise, sequence was completely hidden - return new int[] { visPrev, firstP, lastP }; + return new int[] { firstVisible, lastVisible }; + } finally { LOCK.readLock().unlock(); @@ -954,119 +962,41 @@ public class HiddenColumns } /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). - * - * @param alignmentAnnotation - */ - public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation) - { - makeVisibleAnnotation(-1, -1, alignmentAnnotation); - } - - /** - * delete any columns in alignmentAnnotation that are hidden (including - * sequence associated annotation). + * Finds the hidden region (if any) which starts or ends at res * - * @param start - * remove any annotation to the right of this column - * @param end - * remove any annotation to the left of this column - * @param alignmentAnnotation - * the annotation to operate on + * @param res + * visible residue position, unadjusted for hidden columns + * @return region as [start,end] or null if no matching region is found. If + * res is adjacent to two regions, returns the left region. */ - public void makeVisibleAnnotation(int start, int end, - AlignmentAnnotation alignmentAnnotation) + public int[] getRegionWithEdgeAtRes(int res) { try { LOCK.readLock().lock(); - if (alignmentAnnotation.annotations == null) - { - return; - } - if (start == end && end == -1) - { - start = 0; - end = alignmentAnnotation.annotations.length; - } - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - // then mangle the alignmentAnnotation annotation array - Vector annels = new Vector<>(); - Annotation[] els = null; - int blockStart = start; - int blockEnd = end; - int hideStart; - int hideEnd; - int w = 0; - - for (int[] region : hiddenColumns) - { - hideStart = region[0]; - hideEnd = region[1]; - - if (hideStart < start) - { - continue; - } - - blockStart = Math.min(blockStart, hideEnd + 1); - blockEnd = Math.min(blockEnd, hideStart); - - if (blockStart > blockEnd) - { - break; - } + int adjres = visibleToAbsoluteColumn(res); - els = new Annotation[blockEnd - blockStart]; - annels.addElement(els); - System.arraycopy(alignmentAnnotation.annotations, blockStart, els, - 0, els.length); - w += els.length; - blockStart = hideEnd + 1; - blockEnd = end; - } + int[] reveal = null; - if (end > blockStart) - { - els = new Annotation[end - blockStart + 1]; - annels.addElement(els); - if ((els.length - + blockStart) <= alignmentAnnotation.annotations.length) - { - // copy just the visible segment of the annotation row - System.arraycopy(alignmentAnnotation.annotations, blockStart, - els, 0, els.length); - } - else - { - // copy to the end of the annotation row - System.arraycopy(alignmentAnnotation.annotations, blockStart, - els, 0, - (alignmentAnnotation.annotations.length - blockStart)); - } - w += els.length; - } - if (w == 0) + if (!hiddenColumns.isEmpty()) + { + // look for a region ending just before adjres + int regionindex = cursor.findRegionForColumn(adjres - 1, false) + .getRegionIndex(); + if (regionindex < hiddenColumns.size() + && hiddenColumns.get(regionindex)[1] == adjres - 1) { - return; + reveal = hiddenColumns.get(regionindex); } - - alignmentAnnotation.annotations = new Annotation[w]; - w = 0; - - for (Annotation[] chnk : annels) + // check if the region ends just after adjres + else if (regionindex < hiddenColumns.size() + && hiddenColumns.get(regionindex)[0] == adjres + 1) { - System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w, - chnk.length); - w += chnk.length; + reveal = hiddenColumns.get(regionindex); } } - else - { - alignmentAnnotation.restrict(start, end); - } + return reveal; + } finally { LOCK.readLock().unlock(); @@ -1074,15 +1004,14 @@ public class HiddenColumns } /** - * - * @return true if there are columns hidden + * Return an iterator over the hidden regions */ - public boolean hasHiddenColumns() + public Iterator iterator() { try { LOCK.readLock().lock(); - return hiddenColumns != null && hiddenColumns.size() > 0; + return new RangeIterator(hiddenColumns); } finally { LOCK.readLock().unlock(); @@ -1090,15 +1019,20 @@ public class HiddenColumns } /** + * Return a bounded iterator over the hidden regions * - * @return true if there are more than one set of columns hidden + * @param start + * position to start from (inclusive, absolute column position) + * @param end + * position to end at (inclusive, absolute column position) + * @return */ - public boolean hasManyHiddenColumns() + public Iterator getBoundedIterator(int start, int end) { try { LOCK.readLock().lock(); - return hiddenColumns != null && hiddenColumns.size() > 1; + return new RangeIterator(start, end, hiddenColumns); } finally { LOCK.readLock().unlock(); @@ -1106,752 +1040,90 @@ public class HiddenColumns } /** - * mark the columns corresponding to gap characters as hidden in the column - * selection + * Return a bounded iterator over the *visible* start positions of hidden + * regions * - * @param sr + * @param start + * position to start from (inclusive, visible column position) + * @param end + * position to end at (inclusive, visible column position) */ - public void hideInsertionsFor(SequenceI sr) + public Iterator getStartRegionIterator(int start, int end) { try { - LOCK.writeLock().lock(); - List inserts = sr.getInsertions(); - for (int[] r : inserts) - { - hideColumns(r[0], r[1]); - } + LOCK.readLock().lock(); + + // get absolute position of column in alignment + 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 + // (absoluteStart-1), then if absoluteStart is the start of a visible + // region we'll get the cursor pointing to the region before, which is + // what we want + HiddenCursorPosition pos = cursor + .findRegionForColumn(absoluteStart - 1, false); + + return new StartRegionIterator(pos, start, end, hiddenColumns); } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } /** - * Unhides, and adds to the selection list, all hidden columns + * Return an iterator over visible *columns* (not regions) between the given + * start and end boundaries + * + * @param start + * first column (inclusive) + * @param end + * last column (inclusive) */ - public void revealAllHiddenColumns(ColumnSelection sel) + public Iterator getVisibleColsIterator(int start, int end) { try { - LOCK.writeLock().lock(); - if (hiddenColumns != null) - { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.get(i); - for (int j = region[0]; j < region[1] + 1; j++) - { - sel.addElement(j); - } - } - } - - hiddenColumns = null; + LOCK.readLock().lock(); + return new RangeElementsIterator( + new VisibleContigsIterator(start, end + 1, hiddenColumns)); } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } /** - * Reveals, and marks as selected, the hidden column range with the given - * start column + * return an iterator over visible segments between the given start and end + * boundaries * * @param start + * first column, inclusive from 0 + * @param end + * last column - not inclusive + * @param useVisibleCoords + * if true, start and end are visible column positions, not absolute + * positions* */ - public void revealHiddenColumns(int start, ColumnSelection sel) - { - try - { - LOCK.writeLock().lock(); - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.get(i); - if (start == region[0]) - { - for (int j = region[0]; j < region[1] + 1; j++) - { - sel.addElement(j); - } - - hiddenColumns.remove(region); - break; - } - } - if (hiddenColumns.size() == 0) - { - hiddenColumns = null; - } - } finally - { - LOCK.writeLock().unlock(); - } - } - - /** - * Add gaps into the sequences aligned to profileseq under the given - * AlignmentView - * - * @param profileseq - * @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) - { - 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 gaps as a Bitset - BitSet gaps = origseq.gapBitset(); - - // now calculate hidden ^ not(gap) - BitSet hidden = new BitSet(); - markHiddenRegions(hidden); - hidden.andNot(gaps); - hiddenColumns = null; - this.hideMarkedBits(hidden); - - // 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 - Iterator regions = iterator(); - ArrayList newhidden = new ArrayList<>(); - - int numGapsBefore = 0; - int gapPosition = 0; - while (regions.hasNext()) - { - // get region coordinates accounting for gaps - // we can rely on gaps not being *in* hidden regions because we already - // removed those - int[] region = regions.next(); - 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 - StringBuffer sb = new StringBuffer(); - for (int s = 0; s < right - left + 1; s++) - { - sb.append(gc); - } - padGaps(sb, left, profileseq, al); - - } - hiddenColumns = newhidden; - } - - /** - * 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(StringBuffer 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)); - } - } - } - } - - /** - * Returns a hashCode built from hidden column ranges - */ - @Override - public int hashCode() - { - try - { - LOCK.readLock().lock(); - int hashCode = 1; - if (hiddenColumns != null) - { - for (int[] hidden : hiddenColumns) - { - hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; - hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; - } - } - return hashCode; - } finally - { - LOCK.readLock().unlock(); - } - } - - /** - * Hide columns corresponding to the marked bits - * - * @param inserts - * - columns map to bits starting from zero - */ - public void hideMarkedBits(BitSet inserts) - { - try - { - LOCK.writeLock().lock(); - for (int firstSet = inserts - .nextSetBit(0), lastSet = 0; firstSet >= 0; firstSet = inserts - .nextSetBit(lastSet)) - { - lastSet = inserts.nextClearBit(firstSet); - hideColumns(firstSet, lastSet - 1); - } - } finally - { - LOCK.writeLock().unlock(); - } - } - - /** - * - * @param inserts - * BitSet where hidden columns will be marked - */ - public void markHiddenRegions(BitSet inserts) - { - try - { - LOCK.readLock().lock(); - if (hiddenColumns == null) - { - return; - } - for (int[] range : hiddenColumns) - { - inserts.set(range[0], range[1] + 1); - } - } finally - { - LOCK.readLock().unlock(); - } - } - - /** - * Calculate the visible start and end index of an alignment. - * - * @param width - * full alignment width - * @return integer array where: int[0] = startIndex, and int[1] = endIndex - */ - public int[] getVisibleStartAndEndIndex(int width) + public VisibleContigsIterator getVisContigsIterator(int start, int end, + boolean useVisibleCoords) { - 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 }; - - if (hiddenColumns == null) - { - return new int[] { startPos, endPos }; - } - - for (int[] hiddenCol : hiddenColumns) - { - lowestRange = (hiddenCol[0] <= startPos) ? hiddenCol : lowestRange; - higestRange = (hiddenCol[1] >= endPos) ? hiddenCol : higestRange; - } - - if (lowestRange[0] == -1 && lowestRange[1] == -1) - { - startPos = alignmentStartEnd[0]; - } - else - { - startPos = lowestRange[1] + 1; - } - - if (higestRange[0] == -1 && higestRange[1] == -1) - { - endPos = alignmentStartEnd[1]; - } - else - { - endPos = higestRange[0] - 1; - } - return new int[] { startPos, endPos }; - } finally + int adjstart = start; + int adjend = end; + if (useVisibleCoords) { - LOCK.readLock().unlock(); + adjstart = visibleToAbsoluteColumn(start); + adjend = visibleToAbsoluteColumn(end); } - } - - /** - * Finds the hidden region (if any) which starts or ends at res - * - * @param res - * visible residue position, unadjusted for hidden columns - * @return region as [start,end] or null if no matching region is found - */ - public int[] getRegionWithEdgeAtRes(int res) - { try { LOCK.readLock().lock(); - int adjres = adjustForHiddenColumns(res); - - int[] reveal = null; - if (hiddenColumns != null) - { - for (int[] region : hiddenColumns) - { - if (adjres + 1 == region[0] || adjres - 1 == region[1]) - { - reveal = region; - break; - } - } - } - return reveal; + return new VisibleContigsIterator(adjstart, adjend, hiddenColumns); } finally { LOCK.readLock().unlock(); } } - - public Iterator iterator() - { - if (hiddenColumns != null) - { - int last = hiddenColumns.get(hiddenColumns.size() - 1)[1]; - return new BoundedHiddenColsIterator(0, last, true); - } - else - { - return new BoundedHiddenColsIterator(0, 0, true); - } - } - - public Iterator getBoundedIterator(int start, int end, - boolean useCopy) - { - return new BoundedHiddenColsIterator(start, end, useCopy); - } - - public Iterator getBoundedStartIterator(int start, int end, - boolean useCopy) - { - return new BoundedStartRegionIterator(start, end, useCopy); - } - - public Iterator getBoundedVisRegionIterator(int start, int end) - { - return new BoundedVisRegionIterator(start, end, true); - } - - /** - * An iterator which iterates over hidden column regions in a range. - * - * @author kmourao - * - */ - - - class BoundedHiddenColsIterator implements Iterator - { - - private int start; // start position to iterate from - - private int end; // end position to iterate to - - // current index in hiddenColumns - private int currentPosition = 0; - - // current column in hiddenColumns - private int[] currentRegion; - - // whether to make a local copy of hiddenColumns - private final boolean useCopy; - - // local copy or reference to hiddenColumns - private List localHidden; - - /** - * Construct an iterator over hiddenColums bounded at - * [lowerBound,upperBound] - * - * @param lowerBound - * lower bound to iterate from - * @param upperBound - * upper bound to iterate to - * @param useCopyCols - * whether to make a local copy of hiddenColumns for iteration (set - * to true if calling from outwith the HiddenColumns class) - */ - BoundedHiddenColsIterator(int lowerBound, int upperBound, - boolean useCopyCols) - { - start = lowerBound; - end = upperBound; - useCopy = useCopyCols; - - try - { - if (useCopy) - { - // assume that if useCopy is false the calling code has locked - // hiddenColumns - LOCK.readLock().lock(); - } - - if (hiddenColumns != null) - { - localHidden = new ArrayList<>(); - - // iterate until a region overlaps with [start,end] - int i = 0; - while ((i < hiddenColumns.size()) - && (hiddenColumns.get(i)[1] < start)) - { - i++; - } - - // iterate from start to end, adding each hidden region. Positions are - // absolute, and all regions which *overlap* [start,end] are added. - while (i < hiddenColumns.size() - && (hiddenColumns.get(i)[0] <= end)) - { - int[] rh; - int[] cp; - rh = hiddenColumns.get(i); - if (rh != null) - { - cp = new int[rh.length]; - System.arraycopy(rh, 0, cp, 0, rh.length); - localHidden.add(cp); - } - i++; - } - } - } - finally - { - if (useCopy) - { - LOCK.readLock().unlock(); - } - } - } - - @Override - public boolean hasNext() - { - return (localHidden != null) - && (currentPosition < localHidden.size()); - } - - @Override - public int[] next() - { - currentRegion = localHidden.get(currentPosition); - currentPosition++; - return currentRegion; - } - } - - class BoundedStartRegionIterator implements Iterator - { - - private int start; // start position to iterate from - - private int end; // end position to iterate to - - // current index in hiddenColumns - private int currentPosition = 0; - - // local copy or reference to hiddenColumns - private List positions = null; - - /** - * Construct an iterator over hiddenColums bounded at - * [lowerBound,upperBound] - * - * @param lowerBound - * lower bound to iterate from - * @param upperBound - * upper bound to iterate to - * @param useCopyCols - * whether to make a local copy of hiddenColumns for iteration (set - * to true if calling from outwith the HiddenColumns class) - */ - BoundedStartRegionIterator(int lowerBound, int upperBound, - boolean useCopy) - { - start = lowerBound; - end = upperBound; - - try - { - if (useCopy) - { - // assume that if useCopy is false the calling code has locked - // hiddenColumns - LOCK.readLock().lock(); - } - - if (hiddenColumns != null) - { - positions = new ArrayList<>(hiddenColumns.size()); - - // navigate to start, keeping count of hidden columns - int i = 0; - int hiddenSoFar = 0; - while ((i < hiddenColumns.size()) - && (hiddenColumns.get(i)[0] < start + hiddenSoFar)) - { - int[] region = hiddenColumns.get(i); - hiddenSoFar += region[1] - region[0] + 1; - i++; - } - - // iterate from start to end, adding start positions of each - // hidden region. Positions are visible columns count, not absolute - while (i < hiddenColumns.size() - && (hiddenColumns.get(i)[0] <= end + hiddenSoFar)) - { - int[] region = hiddenColumns.get(i); - positions.add(region[0] - hiddenSoFar); - hiddenSoFar += region[1] - region[0] + 1; - i++; - } - } - else - { - positions = new ArrayList<>(); - } - } finally - { - if (useCopy) - { - LOCK.readLock().unlock(); - } - } - } - - @Override - public boolean hasNext() - { - return (currentPosition < positions.size()); - } - - @Override - public Integer next() - { - int result = positions.get(currentPosition); - currentPosition++; - return result; - } - } - - class BoundedVisRegionIterator implements Iterator - { - private int start; // start position to iterate from - - private int end; // end position to iterate to - - // current region in visColumns - private int[] currentRegion; - - // current index in visColumns - private int currentPosition = 0; - - private List vcontigs = null; - - /** - * Construct an iterator over visibleColumn regions bounded at - * [lowerBound,upperBound] - * - * @param lowerBound - * lower bound to iterate from - * @param upperBound - * upper bound to iterate to - * @param useCopyCols - * whether to make a local copy for iteration (set to true if - * calling from outwith the HiddenColumns class) - */ - BoundedVisRegionIterator(int lowerBound, int upperBound, - boolean useCopy) - { - try - { - start = lowerBound; - end = upperBound; - - if (useCopy) - { - // assume that if useCopy is false the calling code has locked - // hiddenColumns - LOCK.readLock().lock(); - } - - int visStart = start; - - if (hiddenColumns != null) - { - vcontigs = new ArrayList<>(hiddenColumns.size() + 1); - - // navigate to start, keeping count of hidden columns - int i = 0; - int[] region = null; - while ((i < hiddenColumns.size()) - && (hiddenColumns.get(i)[0] <= start)) - { - i++; - } - // if there was a hidden region before (i>=1), and it ended after - // start - // and before end, adjust visStart to be just after that region - if (i > 0) - { - region = hiddenColumns.get(i - 1); - if ((region[1] > start) && (region[1] < end)) - { - visStart = region[1] + 1; - } - else if (region[1] >= end) - { - // previous hidden region covers whole range [start,end] - // early exit - vcontigs is empty - return; - } - } - - // iterate from start to end, adding start positions of each - // hidden region. Positions are visible columns count, not absolute - while (i < hiddenColumns.size() - && (hiddenColumns.get(i)[0] < end)) - { - region = hiddenColumns.get(i); - int[] prevVisibleRegion = new int[] { visStart, region[0] - 1 }; - vcontigs.add(prevVisibleRegion); - visStart = region[1] + 1; - i++; - } - // add on a final visible region if needed - if (visStart <= end) - { - int[] lastRegion = new int[] { visStart, end }; - vcontigs.add(lastRegion); - } - } - else - { - vcontigs = new ArrayList<>(); - int[] lastRegion = new int[] { start, end }; - vcontigs.add(lastRegion); - } - } finally - { - if (useCopy) - { - LOCK.readLock().unlock(); - } - } - } - - @Override - public boolean hasNext() - { - return (currentPosition < vcontigs.size()); - } - - @Override - public int[] next() - { - currentRegion = vcontigs.get(currentPosition); - currentPosition++; - return currentRegion; - } - } }