X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=fb1961eca932ae4bfbf359e2841fb392e67e0f09;hb=a3c835f0495ade5c3ae7968dd9727c03710d870b;hp=09f2ec5077a578ee509b72ef46bf9232e59acff4;hpb=02bdd4e842db62a0c9c3a36bbddd2b4f7249df92;p=jalview.git diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java index 09f2ec5..fb1961e 100644 --- a/src/jalview/datamodel/HiddenColumns.java +++ b/src/jalview/datamodel/HiddenColumns.java @@ -20,14 +20,11 @@ */ package jalview.datamodel; -import jalview.util.Comparison; - import java.util.ArrayList; import java.util.BitSet; import java.util.Iterator; import java.util.List; import java.util.NoSuchElementException; -import java.util.Vector; import java.util.concurrent.locks.ReentrantReadWriteLock; public class HiddenColumns @@ -63,7 +60,12 @@ public class HiddenColumns { if (copy.hiddenColumns != null) { - hiddenColumns = copy.copyHiddenRegionsToArrayList(0); + hiddenColumns = new ArrayList<>(); + Iterator it = copy.iterator(); + while (it.hasNext()) + { + hiddenColumns.add(it.next()); + } } } } finally @@ -131,15 +133,16 @@ public class HiddenColumns { LOCK.readLock().lock(); StringBuilder regionBuilder = new StringBuilder(); - if (hiddenColumns != null) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - for (int[] range : hiddenColumns) - { - regionBuilder.append(delimiter).append(range[0]).append(between) + int[] range = it.next(); + regionBuilder.append(delimiter).append(range[0]).append(between) .append(range[1]); + if (!it.hasNext()) + { + regionBuilder.deleteCharAt(0); } - - regionBuilder.deleteCharAt(0); } return regionBuilder.toString(); } finally @@ -159,13 +162,13 @@ public class HiddenColumns { LOCK.readLock().lock(); int size = 0; - if (hasHiddenColumns()) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - for (int[] range : hiddenColumns) - { - size += range[1] - range[0] + 1; - } + int[] range = it.next(); + size += range[1] - range[0] + 1; } + return size; } finally { @@ -220,10 +223,13 @@ public class HiddenColumns { return false; } - int i = 0; - for (int[] thisRange : hiddenColumns) + + Iterator it = new RegionsIterator(); + Iterator thatit = that.iterator(); + while (it.hasNext()) { - int[] thatRange = that.hiddenColumns.get(i++); + int[] thisRange = it.next(); + int[] thatRange = thatit.next(); if (thisRange[0] != thatRange[0] || thisRange[1] != thatRange[1]) { return false; @@ -249,17 +255,17 @@ public class HiddenColumns { LOCK.readLock().lock(); int result = column; - if (hiddenColumns != null) + + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - for (int i = 0; i < hiddenColumns.size(); i++) + int[] region = it.next(); + if (result >= region[0]) { - int[] region = hiddenColumns.get(i); - if (result >= region[0]) - { - result += region[1] - region[0] + 1; - } + result += region[1] - region[0] + 1; } } + return result; } finally { @@ -282,29 +288,30 @@ public class HiddenColumns { LOCK.readLock().lock(); int result = hiddenColumn; + int[] region = null; if (hiddenColumns != null) { - int index = 0; - int[] region; - do + Iterator it = new RegionsIterator(0, + hiddenColumn); + while (it.hasNext()) { - region = hiddenColumns.get(index++); + region = it.next(); 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 (region != null && hiddenColumn >= region[0] + && hiddenColumn <= region[1]) { // 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 + // 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 @@ -341,64 +348,48 @@ public class HiddenColumns { 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; + Iterator it = new ReverseRegionsIterator(0, start); - while ((index > -1) && (distance - gap > 0)) + while (it.hasNext() && (distance > 0)) { - // subtract the gap to right of region from distance - distance -= gap; - start = nextstart; - - // calculate the next gap - region = hiddenColumns.get(index); - gap = start - region[1]; + int[] region = it.next(); - // set start to just to left of current region - nextstart = region[0] - 1; - index--; + if (start > region[1]) + { + // subtract the gap to right of region from distance + if (start - region[1] <= distance) + { + distance -= start - region[1]; + start = region[0] - 1; + } + else + { + start = start - distance; + distance = 0; + } + } } - 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(); } - } - - /** * This method returns the rightmost limit of a region of an alignment with * hidden columns. In otherwords, the next hidden column. * - * @param index - * int + * @param alPos + * the (visible) alignmentPosition to find the next hidden column for */ public int getHiddenBoundaryRight(int alPos) { @@ -407,33 +398,30 @@ public class HiddenColumns LOCK.readLock().lock(); if (hiddenColumns != null) { - int index = 0; - do + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - int[] region = hiddenColumns.get(index); + int[] region = it.next(); if (alPos < region[0]) { return region[0]; } - - index++; - } while (index < hiddenColumns.size()); + } } - 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 + * @param alPos + * the (visible) alignmentPosition to find the previous hidden column + * for */ public int getHiddenBoundaryLeft(int alPos) { @@ -441,19 +429,14 @@ public class HiddenColumns { LOCK.readLock().lock(); - if (hiddenColumns != null) + Iterator it = new ReverseRegionsIterator(0, alPos); + while (it.hasNext()) { - int index = hiddenColumns.size() - 1; - do + int[] region = it.next(); + if (alPos > region[1]) { - int[] region = hiddenColumns.get(index); - if (alPos > region[1]) - { - return region[1]; - } - - index--; - } while (index > -1); + return region[1]; + } } return alPos; @@ -464,47 +447,12 @@ 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 - */ - private int getHiddenIndexLeft(int pos) - { - 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; - } finally - { - LOCK.readLock().unlock(); - } - - } - - /** - * Adds the specified column range to the hidden columns + * 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) { @@ -528,66 +476,25 @@ public class HiddenColumns } /* - * traverse existing hidden ranges and insert / amend / append as - * appropriate + * new range follows everything else; check first to avoid looping over whole hiddenColumns collection */ - for (int i = 0; i < hiddenColumns.size(); i++) + if (hiddenColumns.isEmpty() + || start > hiddenColumns.get(hiddenColumns.size() - 1)[1]) { - 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) + hiddenColumns.add(new int[] { start, end }); + } + else + { + /* + * traverse existing hidden ranges and insert / amend / append as + * appropriate + */ + boolean added = false; + for (int i = 0; !added && i < hiddenColumns.size(); i++) { - /* - * 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; - } + added = insertRangeAtRegion(i, start, end); + } // for } - - /* - * remaining case is that the new range follows everything else - */ - hiddenColumns.add(new int[] { start, end }); } finally { if (!wasAlreadyLocked) @@ -597,55 +504,100 @@ public class HiddenColumns } } - public boolean isVisible(int column) + private boolean insertRangeAtRegion(int i, int start, int end) { - try + boolean added = false; + + int[] region = hiddenColumns.get(i); + if (end < region[0] - 1) { - LOCK.readLock().lock(); + /* + * insert discontiguous preceding range + */ + hiddenColumns.add(i, new int[] { start, end }); + added = true; + } + else if (end <= region[1]) + { + /* + * new range overlaps existing, or is contiguous preceding it - adjust + * start column + */ + region[0] = Math.min(region[0], start); + added = true; + } + else 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); - if (hiddenColumns != null) + /* + * also update or remove any subsequent ranges + * that are overlapped + */ + while (i < hiddenColumns.size() - 1) { - for (int[] region : hiddenColumns) + int[] nextRegion = hiddenColumns.get(i + 1); + if (nextRegion[0] > end + 1) { - if (column >= region[0] && column <= region[1]) - { - return false; - } + /* + * gap to next hidden range - no more to update + */ + break; } + region[1] = Math.max(nextRegion[1], end); + hiddenColumns.remove(i + 1); } - - return true; - } finally - { - LOCK.readLock().unlock(); + added = true; } + return added; } - private ArrayList copyHiddenRegionsToArrayList(int startIndex) + /** + * Answers if a column in the alignment is visible + * + * @param column + * absolute position of column in the alignment + * @return true if column is visible + */ + public boolean isVisible(int column) { - int size = 0; - if (hiddenColumns != null) + try { - size = hiddenColumns.size(); - } - ArrayList copy = new ArrayList<>(size); + LOCK.readLock().lock(); - for (int i = startIndex, j = size; i < j; i++) - { - int[] rh; - int[] cp; - rh = hiddenColumns.get(i); - if (rh != null) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - cp = new int[rh.length]; - System.arraycopy(rh, 0, cp, 0, rh.length); - copy.add(cp); + int[] region = it.next(); + if (column >= region[0] && column <= region[1]) + { + return false; + } } - } - return copy; + return true; + } finally + { + LOCK.readLock().unlock(); + } } + /** + * 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) { @@ -660,12 +612,22 @@ public class HiddenColumns { StringBuffer visibleSeq = new StringBuffer(); - Iterator blocks = new VisibleBlocksIterator(start, - end, false); + Iterator blocks = new VisibleContigsIterator(start, + end + 1, false); + while (blocks.hasNext()) { int[] block = blocks.next(); - visibleSeq.append(seqs[i].getSequence(block[0], block[1])); + 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(); @@ -687,15 +649,14 @@ public class HiddenColumns } /** - * 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 + * 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 - * @return int[] { visible start, first seqpos, last seqpos } + * sequence to find position for + * @return visible start position */ - public int locateVisibleBoundsOfSequence(SequenceI seq) + public int locateVisibleStartOfSequence(SequenceI seq) { try { @@ -709,41 +670,40 @@ public class HiddenColumns // Simply walk along the sequence whilst watching for hidden column // boundaries - Iterator regions = iterator(); - int spos = seq.getStart(); + Iterator regions = new RegionsIterator(); int hideStart = seq.getLength(); int hideEnd = -1; int visPrev = 0; int visNext = 0; - boolean foundStart = false; - for (int p = 0; spos <= seq.getEnd() && p < seq.getLength(); p++) + + // step through the non-gapped positions of the sequence + for (int i = seq.getStart(); i <= seq.getEnd() && (!foundStart); i++) { - if (!Comparison.isGap(seq.getCharAt(p))) + // 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()) { - // 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) && (!foundStart)) - { - start = p; - foundStart = true; - } - // look for next sequence position - spos++; + 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 findColumnPosition(start); @@ -810,28 +770,28 @@ public class HiddenColumns AlignmentAnnotation alignmentAnnotation) { // mangle the alignmentAnnotation annotation array - Vector annels = new Vector<>(); + ArrayList annels = new ArrayList<>(); Annotation[] els = null; int w = 0; - Iterator blocks = new VisibleBlocksIterator(start, end, + Iterator blocks = new VisibleContigsIterator(start, end + 1, false); + int copylength; int annotationLength; while (blocks.hasNext()) { int[] block = blocks.next(); + annotationLength = block[1] - block[0] + 1; if (blocks.hasNext()) { - annotationLength = block[1] - block[0]; // copy just the visible segment of the annotation row copylength = annotationLength; } else { - annotationLength = block[1] - block[0] + 1; if (annotationLength + block[0] <= alignmentAnnotation.annotations.length) { // copy just the visible segment of the annotation row @@ -845,7 +805,7 @@ public class HiddenColumns } els = new Annotation[annotationLength]; - annels.addElement(els); + annels.add(els); System.arraycopy(alignmentAnnotation.annotations, block[0], els, 0, copylength); w += annotationLength; @@ -927,15 +887,13 @@ public class HiddenColumns try { LOCK.writeLock().lock(); - if (hiddenColumns != null) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - for (int i = 0; i < hiddenColumns.size(); i++) + int[] region = it.next(); + for (int j = region[0]; j < region[1] + 1; j++) { - int[] region = hiddenColumns.get(i); - for (int j = region[0]; j < region[1] + 1; j++) - { - sel.addElement(j); - } + sel.addElement(j); } } @@ -957,9 +915,10 @@ public class HiddenColumns try { LOCK.writeLock().lock(); - for (int i = 0; i < hiddenColumns.size(); i++) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - int[] region = hiddenColumns.get(i); + int[] region = it.next(); if (start == region[0]) { for (int j = region[0]; j < region[1] + 1; j++) @@ -970,7 +929,12 @@ public class HiddenColumns hiddenColumns.remove(region); break; } + else if (start < region[0]) + { + break; // passed all possible matching regions + } } + if (hiddenColumns.size() == 0) { hiddenColumns = null; @@ -1045,7 +1009,7 @@ public class HiddenColumns // of // preceding visible gaps // update hidden columns at the same time - Iterator regions = iterator(); + Iterator regions = new RegionsIterator(); ArrayList newhidden = new ArrayList<>(); int numGapsBefore = 0; @@ -1150,13 +1114,12 @@ public class HiddenColumns { LOCK.readLock().lock(); int hashCode = 1; - if (hiddenColumns != null) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - for (int[] hidden : hiddenColumns) - { - hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; - hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; - } + int[] hidden = it.next(); + hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; + hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; } return hashCode; } finally @@ -1203,8 +1166,10 @@ public class HiddenColumns { return; } - for (int[] range : hiddenColumns) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { + int[] range = it.next(); inserts.set(range[0], range[1] + 1); } } finally @@ -1237,10 +1202,12 @@ public class HiddenColumns return new int[] { startPos, endPos }; } - for (int[] hiddenCol : hiddenColumns) + Iterator it = new RegionsIterator(); + while (it.hasNext()) { - lowestRange = (hiddenCol[0] <= startPos) ? hiddenCol : lowestRange; - higestRange = (hiddenCol[1] >= endPos) ? hiddenCol : higestRange; + int[] range = it.next(); + lowestRange = (range[0] <= startPos) ? range : lowestRange; + higestRange = (range[1] >= endPos) ? range : higestRange; } if (lowestRange[0] == -1 && lowestRange[1] == -1) @@ -1283,15 +1250,15 @@ public class HiddenColumns int adjres = adjustForHiddenColumns(res); int[] reveal = null; - if (hiddenColumns != null) + Iterator it = new RegionsIterator(adjres - 2, + adjres + 2); + while (it.hasNext()) { - for (int[] region : hiddenColumns) + int[] region = it.next(); + if (adjres + 1 == region[0] || adjres - 1 == region[1]) { - if (adjres + 1 == region[0] || adjres - 1 == region[1]) - { - reveal = region; - break; - } + reveal = region; + break; } } return reveal; @@ -1306,15 +1273,7 @@ public class HiddenColumns */ 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); - } + return new BoundedHiddenColsIterator(); } /** @@ -1328,7 +1287,7 @@ public class HiddenColumns */ public Iterator getBoundedIterator(int start, int end) { - return new BoundedHiddenColsIterator(start, end, true); + return new BoundedHiddenColsIterator(start, end); } /** @@ -1346,8 +1305,8 @@ public class HiddenColumns } /** - * Return an iterator over visible columns between the given start and end - * boundaries + * Return an iterator over visible *columns* (not regions) between the given + * start and end boundaries * * @param start * first column (inclusive) @@ -1356,7 +1315,7 @@ public class HiddenColumns */ public Iterator getVisibleColsIterator(int start, int end) { - return new VisibleColsIterator(start, end, true); + return new VisibleColsIterator(start, end); } /** @@ -1370,6 +1329,7 @@ public class HiddenColumns */ public Iterator getVisContigsIterator(int start, int end) { + // return new VisibleBlocksIterator(start, end, true) return new VisibleContigsIterator(start, end, true); } @@ -1393,25 +1353,207 @@ public class HiddenColumns // TODO // we should really just convert start and end here with // adjustForHiddenColumns - // and then create a VisibleBlocksIterator + // and then create a VisibleContigsIterator // but without a cursor this will be horribly slow in some situations // ... so until then... return new VisibleBlocksVisBoundsIterator(start, end, true); } else { - return new VisibleBlocksIterator(start, end, true); + return new VisibleContigsIterator(start, end - 1, true); } } /** - * An iterator which iterates over hidden column regions in a range. + * A local iterator which iterates over hidden column regions in a range. + * Intended for use ONLY within the HiddenColumns class, because it works + * directly with the hiddenColumns collection without locking (callers should + * lock hiddenColumns). + */ + private class RegionsIterator implements Iterator + { + // start position to iterate from + private int start; + + // end position to iterate to + private int end; + + // current index in hiddenColumns + private int currentPosition = 0; + + // current column in hiddenColumns + private int[] nextRegion = null; + + // Constructor with bounds + RegionsIterator(int lowerBound, int upperBound) + { + init(lowerBound, upperBound); + } + + // Unbounded constructor + RegionsIterator() + { + if (hiddenColumns != null) + { + // iterator over full hiddenColumns collection + int last = hiddenColumns.get(hiddenColumns.size() - 1)[1]; + init(0, last); + } + else + { + // empty iterator + init(0, 0); + } + } + + /** + * Construct an iterator over hiddenColums bounded at + * [lowerBound,upperBound] + * + * @param lowerBound + * lower bound to iterate from + * @param upperBound + * upper bound to iterate to + */ + private void init(int lowerBound, int upperBound) + { + start = lowerBound; + end = upperBound; + + if (hiddenColumns != null) + { + // iterate until a region overlaps with [start,end] + currentPosition = 0; + while ((currentPosition < hiddenColumns.size()) + && (hiddenColumns.get(currentPosition)[1] < start)) + { + currentPosition++; + } + if (currentPosition < hiddenColumns.size()) + { + nextRegion = hiddenColumns.get(currentPosition); + } + } + } + + @Override + public boolean hasNext() + { + return (hiddenColumns != null) && (nextRegion != null) + && (nextRegion[0] <= end); + } + + @Override + public int[] next() + { + int[] region = nextRegion; + currentPosition++; + if (currentPosition < hiddenColumns.size()) + { + nextRegion = hiddenColumns.get(currentPosition); + } + else + { + nextRegion = null; + } + return region; + } + + } + + /** + * A local iterator which reverse iterates over hidden column regions in a + * range. Intended for use ONLY within the HiddenColumns class, because it + * works directly with the hiddenColumns collection without locking (callers + * should lock hiddenColumns). + */ + private class ReverseRegionsIterator implements Iterator + { + // start position to iterate to + private int start; + + // end position to iterate from + private int end; + + // current index in hiddenColumns + private int currentPosition = 0; + + // current column in hiddenColumns + private int[] nextRegion = null; + + // Constructor with bounds + ReverseRegionsIterator(int lowerBound, int upperBound) + { + init(lowerBound, upperBound); + } + + /** + * Construct an iterator over hiddenColums bounded at + * [lowerBound,upperBound] + * + * @param lowerBound + * lower bound to iterate to + * @param upperBound + * upper bound to iterate from + */ + private void init(int lowerBound, int upperBound) + { + start = lowerBound; + end = upperBound; + + if (hiddenColumns != null) + { + // iterate until a region overlaps with [start,end] + currentPosition = hiddenColumns.size() - 1; + while (currentPosition >= 0 + && hiddenColumns.get(currentPosition)[1] > end) + { + currentPosition--; + } + if (currentPosition >= 0) + { + nextRegion = hiddenColumns.get(currentPosition); + } + } + } + + @Override + public boolean hasNext() + { + return (hiddenColumns != null) && (nextRegion != null) + && (nextRegion[1] >= start); + } + + @Override + public int[] next() + { + int[] region = nextRegion; + currentPosition--; + if (currentPosition >= 0) + { + nextRegion = hiddenColumns.get(currentPosition); + } + else + { + nextRegion = null; + } + return region; + } + + } + + /** + * An iterator which iterates over hidden column regions in a range. Works + * with a copy of the hidden columns collection. Intended to be used by + * callers OUTSIDE of HiddenColumns. */ private class BoundedHiddenColsIterator implements Iterator { - private int start; // start position to iterate from + // start position to iterate from + private int start; - private int end; // end position to iterate to + // end position to iterate to + private int end; // current index in hiddenColumns private int currentPosition = 0; @@ -1419,13 +1561,26 @@ public class HiddenColumns // 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; /** + * Unbounded constructor + */ + BoundedHiddenColsIterator() + { + if (hiddenColumns != null) + { + int last = hiddenColumns.get(hiddenColumns.size() - 1)[1]; + init(0, last); + } + else + { + init(0, 0); + } + } + + /** * Construct an iterator over hiddenColums bounded at * [lowerBound,upperBound] * @@ -1433,25 +1588,29 @@ public class HiddenColumns * 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) + BoundedHiddenColsIterator(int lowerBound, int upperBound) + { + init(lowerBound, upperBound); + } + + /** + * Construct an iterator over hiddenColums bounded at + * [lowerBound,upperBound] + * + * @param lowerBound + * lower bound to iterate from + * @param upperBound + * upper bound to iterate to + */ + private void init(int lowerBound, int upperBound) { start = lowerBound; end = upperBound; - useCopy = useCopyCols; try { - if (useCopy) - { - // assume that if useCopy is false the calling code has locked - // hiddenColumns - LOCK.readLock().lock(); - } + LOCK.readLock().lock(); if (hiddenColumns != null) { @@ -1470,25 +1629,17 @@ public class HiddenColumns 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); - } + int[] rh = hiddenColumns.get(i); + int[] cp = new int[2]; + System.arraycopy(rh, 0, cp, 0, rh.length); + localHidden.add(cp); i++; } } } finally { - if (useCopy) - { - LOCK.readLock().unlock(); - } + LOCK.readLock().unlock(); } } @@ -1612,6 +1763,13 @@ public class HiddenColumns } } + /** + * Iterator over the visible *columns* (not regions) as determined by the set + * of hidden columns. Uses a local copy of hidden columns. + * + * @author kmourao + * + */ private class VisibleColsIterator implements Iterator { private int last; @@ -1624,67 +1782,54 @@ public class HiddenColumns private int nexthiddenregion; - VisibleColsIterator(int firstcol, int lastcol, boolean useCopy) + VisibleColsIterator(int firstcol, int lastcol) { last = lastcol; current = firstcol; next = firstcol; nexthiddenregion = 0; - try - { - if (useCopy) - { - // assume that if useCopy is false the calling code has locked - // hiddenColumns - LOCK.readLock().lock(); - } + LOCK.readLock().lock(); - if (hiddenColumns != null) + if (hiddenColumns != null) + { + int i = 0; + for (i = 0; i < hiddenColumns.size() + && (current <= hiddenColumns.get(i)[0]); ++i) { - int i = 0; - for (i = 0; i < hiddenColumns.size() - && (current <= hiddenColumns.get(i)[0]); ++i) - { - if (current >= hiddenColumns.get(i)[0] - && current <= hiddenColumns.get(i)[1]) - { - // current is hidden, move to right - current = hiddenColumns.get(i)[1] + 1; - next = current; - nexthiddenregion = i + 1; - } - } - - for (i = hiddenColumns.size() - 1; i >= 0 - && (last >= hiddenColumns.get(i)[1]); --i) + if (current >= hiddenColumns.get(i)[0] + && current <= hiddenColumns.get(i)[1]) { - if (last >= hiddenColumns.get(i)[0] - && last <= hiddenColumns.get(i)[1]) - { - // last is hidden, move to left - last = hiddenColumns.get(i)[0] - 1; - } + // current is hidden, move to right + current = hiddenColumns.get(i)[1] + 1; + next = current; + nexthiddenregion = i + 1; } + } - // make a local copy of the bit we need - i = nexthiddenregion; - while (i < hiddenColumns.size() - && hiddenColumns.get(i)[0] <= last) + for (i = hiddenColumns.size() - 1; i >= 0 + && (last >= hiddenColumns.get(i)[1]); --i) + { + if (last >= hiddenColumns.get(i)[0] + && last <= hiddenColumns.get(i)[1]) { - int[] region = new int[] { hiddenColumns.get(i)[0], - hiddenColumns.get(i)[1] }; - localHidden.add(region); - i++; + // last is hidden, move to left + last = hiddenColumns.get(i)[0] - 1; } } - } finally - { - if (useCopy) + + // make a local copy of the bit we need + i = nexthiddenregion; + while (i < hiddenColumns.size() && hiddenColumns.get(i)[0] <= last) { - LOCK.readLock().unlock(); + int[] region = new int[] { hiddenColumns.get(i)[0], + hiddenColumns.get(i)[1] }; + localHidden.add(region); + i++; } } + + LOCK.readLock().unlock(); } @Override @@ -1817,91 +1962,6 @@ public class HiddenColumns } /** - * An iterator which iterates over visible regions in a range. - */ - private class VisibleBlocksIterator implements Iterator - { - private List vcontigs = new ArrayList<>(); - - private int currentPosition = 0; - - VisibleBlocksIterator(int start, int end, boolean usecopy) - { - try - { - if (usecopy) - { - LOCK.readLock().lock(); - } - - if (hiddenColumns != null && hiddenColumns.size() > 0) - { - int blockStart = start; - int blockEnd = end; - - // 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 used. - while (i < hiddenColumns.size() - && (hiddenColumns.get(i)[0] <= end)) - { - int[] region = hiddenColumns.get(i); - - blockStart = Math.min(blockStart, region[1] + 1); - blockEnd = Math.min(blockEnd, region[0]); - - int[] contig = new int[] { blockStart, blockEnd }; - vcontigs.add(contig); - - blockStart = region[1] + 1; - blockEnd = end; - - i++; - } - - if (end > blockStart) - { - int[] contig = new int[] { blockStart, end }; - vcontigs.add(contig); - } - } - else - { - int[] contig = new int[] { start, end }; - vcontigs.add(contig); - } - } finally - { - if (usecopy) - { - LOCK.readLock().unlock(); - } - } - } - - @Override - public boolean hasNext() - { - return (currentPosition < vcontigs.size()); - } - - @Override - public int[] next() - { - int[] result = vcontigs.get(currentPosition); - currentPosition++; - return result; - } - } - - /** * An iterator which iterates over visible regions in a range. The range is * specified in terms of visible column positions. Provides a special * "endsAtHidden" indicator to allow callers to determine if the final visible @@ -2035,5 +2095,4 @@ public class HiddenColumns return endsAtHidden; } } - }