X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=839cee2da147dbde05f2750d3245ed05ae4754a1;hb=8213e48c6973494f7a6e22e1a97290520a461d1b;hp=b53fc8bda336625ad93aa452a33625e673c81f1b;hpb=607a4aecda2f99866bb1acf7d364a6dde4e215bd;p=jalview.git diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java index b53fc8b..839cee2 100644 --- a/src/jalview/datamodel/HiddenColumns.java +++ b/src/jalview/datamodel/HiddenColumns.java @@ -21,34 +21,98 @@ package jalview.datamodel; import jalview.util.Comparison; -import jalview.util.ShiftList; import java.util.ArrayList; import java.util.BitSet; -import java.util.Collections; +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 { + private static final int HASH_MULTIPLIER = 31; + private static final ReentrantReadWriteLock LOCK = new ReentrantReadWriteLock(); - + /* * list of hidden column [start, end] ranges; the list is maintained in * ascending start column order */ - private Vector hiddenColumns; + private ArrayList hiddenColumns; + + /** + * Constructor + */ + public HiddenColumns() + { + } + + /** + * Copy constructor + * + * @param copy + */ + public HiddenColumns(HiddenColumns copy) + { + try + { + LOCK.writeLock().lock(); + if (copy != null) + { + if (copy.hiddenColumns != null) + { + hiddenColumns = copy.copyHiddenRegionsToArrayList(0); + } + } + } finally + { + LOCK.writeLock().unlock(); + } + } /** - * This Method is used to return all the HiddenColumn regions + * Copy constructor within bounds and with offset. Copies hidden column + * regions fully contained between start and end, and offsets positions by + * subtracting offset. + * + * @param copy + * HiddenColumns instance to copy from + * @param start + * lower bound to copy from + * @param end + * upper bound to copy to + * @param offset + * offset to subtract from each region boundary position * - * @return empty list or List of hidden column intervals */ - private List getHiddenRegions() + public HiddenColumns(HiddenColumns copy, int start, int end, int offset) { - return hiddenColumns == null ? Collections. emptyList() - : hiddenColumns; + try + { + LOCK.writeLock().lock(); + if (copy != null) + { + hiddenColumns = new ArrayList<>(); + Iterator it = copy.getBoundedIterator(start, end); + while (it.hasNext()) + { + int[] region = it.next(); + // still need to check boundaries because iterator returns + // 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 }); + } + } + } + } finally + { + LOCK.writeLock().unlock(); + } } /** @@ -95,7 +159,7 @@ public class HiddenColumns { LOCK.readLock().lock(); int size = 0; - if (hasHidden()) + if (hasHiddenColumns()) { for (int[] range : hiddenColumns) { @@ -103,29 +167,32 @@ public class HiddenColumns } } return size; - } - finally + } finally { LOCK.readLock().unlock(); } } /** - * Answers if there are any hidden columns + * Get the number of distinct hidden regions * - * @return true if there are hidden columns + * @return number of regions */ - public boolean hasHidden() + public int getNumberOfRegions() { try { LOCK.readLock().lock(); - return (hiddenColumns != null) && (!hiddenColumns.isEmpty()); + int num = 0; + if (hasHiddenColumns()) + { + num = hiddenColumns.size(); + } + return num; } finally { LOCK.readLock().unlock(); } - } @Override @@ -186,7 +253,7 @@ public class HiddenColumns { for (int i = 0; i < hiddenColumns.size(); i++) { - int[] region = hiddenColumns.elementAt(i); + int[] region = hiddenColumns.get(i); if (result >= region[0]) { result += region[1] - region[0] + 1; @@ -221,7 +288,7 @@ public class HiddenColumns int[] region; do { - region = hiddenColumns.elementAt(index++); + region = hiddenColumns.get(index++); if (hiddenColumn > region[1]) { result -= region[1] + 1 - region[0]; @@ -276,47 +343,47 @@ public class HiddenColumns { LOCK.readLock().lock(); - int distance = visibleDistance; + int distance = visibleDistance; - // in case startColumn is in a hidden region, move it to the left - int start = adjustForHiddenColumns(findColumnPosition(startColumn)); + // 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; - } + // 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; + // 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; + while ((index > -1) && (distance - gap > 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]; + // 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--; - } + // 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; + 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(); @@ -324,56 +391,7 @@ public class HiddenColumns } - /** - * Use this method to determine the set of hiddenRegion start positions - * - * @return list of column number in visible view where hidden regions start - */ - public List findHiddenRegionPositions() - { - try - { - LOCK.readLock().lock(); - List positions = null; - - if (hiddenColumns != null) - { - positions = new ArrayList<>(hiddenColumns.size()); - - positions.add(hiddenColumns.elementAt(0)[0]); - for (int i = 1; i < hiddenColumns.size(); ++i) - { - - int result = 0; - if (hiddenColumns != null) - { - int index = 0; - int gaps = 0; - do - { - int[] region = hiddenColumns.elementAt(index); - gaps += region[1] + 1 - region[0]; - result = region[1] + 1; - index++; - } while (index <= i); - - result -= gaps; - } - positions.add(result); - } - } - else - { - positions = new ArrayList<>(); - } - return positions; - } - finally - { - LOCK.readLock().unlock(); - } - } /** * This method returns the rightmost limit of a region of an alignment with @@ -392,7 +410,7 @@ public class HiddenColumns int index = 0; do { - int[] region = hiddenColumns.elementAt(index); + int[] region = hiddenColumns.get(index); if (alPos < region[0]) { return region[0]; @@ -423,22 +441,22 @@ public class HiddenColumns { LOCK.readLock().lock(); - if (hiddenColumns != null) - { - int index = hiddenColumns.size() - 1; - do + if (hiddenColumns != null) { - int[] region = hiddenColumns.elementAt(index); - if (alPos > region[1]) + int index = hiddenColumns.size() - 1; + do { - return region[1]; - } + int[] region = hiddenColumns.get(index); + if (alPos > region[1]) + { + return region[1]; + } - index--; - } while (index > -1); - } + index--; + } while (index > -1); + } - return alPos; + return alPos; } finally { LOCK.readLock().unlock(); @@ -459,22 +477,22 @@ public class HiddenColumns { LOCK.readLock().lock(); - if (hiddenColumns != null) - { - int index = hiddenColumns.size() - 1; - do + if (hiddenColumns != null) { - int[] region = hiddenColumns.elementAt(index); - if (pos > region[1]) + int index = hiddenColumns.size() - 1; + do { - return index; - } + int[] region = hiddenColumns.get(index); + if (pos > region[1]) + { + return index; + } - index--; - } while (index > -1); - } + index--; + } while (index > -1); + } - return -1; + return -1; } finally { LOCK.readLock().unlock(); @@ -490,28 +508,23 @@ public class HiddenColumns */ public void hideColumns(int start, int end) { - hideColumns(start, end, false); - } - - /** - * Adds the specified column range to the hidden columns - * - * @param start - * @param end - */ - private void hideColumns(int start, int end, boolean alreadyLocked) - { + boolean wasAlreadyLocked = false; try { - - if (!alreadyLocked) + // 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 Vector<>(); + hiddenColumns = new ArrayList<>(); } /* @@ -520,14 +533,14 @@ public class HiddenColumns */ for (int i = 0; i < hiddenColumns.size(); i++) { - int[] region = hiddenColumns.elementAt(i); + int[] region = hiddenColumns.get(i); if (end < region[0] - 1) { /* * insert discontiguous preceding range */ - hiddenColumns.insertElementAt(new int[] { start, end }, i); + hiddenColumns.add(i, new int[] { start, end }); return; } @@ -569,15 +582,15 @@ public class HiddenColumns } return; } - } + } - /* - * remaining case is that the new range follows everything else - */ - hiddenColumns.addElement(new int[] { start, end }); + /* + * remaining case is that the new range follows everything else + */ + hiddenColumns.add(new int[] { start, end }); } finally { - if (!alreadyLocked) + if (!wasAlreadyLocked) { LOCK.writeLock().unlock(); } @@ -590,75 +603,25 @@ public class HiddenColumns { LOCK.readLock().lock(); - if (hiddenColumns != null) - { - for (int[] region : hiddenColumns) + if (hiddenColumns != null) { - if (column >= region[0] && column <= region[1]) + for (int[] region : hiddenColumns) { - return false; + if (column >= region[0] && column <= region[1]) + { + return false; + } } } - } - return true; + return true; } finally { LOCK.readLock().unlock(); } } - /** - * ColumnSelection - */ - public HiddenColumns() - { - } - - /** - * Copy constructor - * - * @param copy - */ - public HiddenColumns(HiddenColumns copy) - { - try - { - - LOCK.readLock().lock(); - if (copy != null) - { - if (copy.hiddenColumns != null) - { - hiddenColumns = copy.copyHiddenRegions(); - } - } - } - finally - { - LOCK.readLock().unlock(); - } - } - - private Vector copyHiddenRegions() - { - Vector copy = new Vector<>(hiddenColumns.size()); - for (int i = 0, j = hiddenColumns.size(); i < j; i++) - { - int[] rh; - int[] cp; - rh = hiddenColumns.elementAt(i); - if (rh != null) - { - cp = new int[rh.length]; - System.arraycopy(rh, 0, cp, 0, rh.length); - copy.addElement(cp); - } - } - return copy; - } - - private ArrayList copyHiddenRegionsToArrayList() + private ArrayList copyHiddenRegionsToArrayList(int startIndex) { int size = 0; if (hiddenColumns != null) @@ -667,11 +630,11 @@ public class HiddenColumns } ArrayList copy = new ArrayList<>(size); - for (int i = 0, j = size; i < j; i++) + for (int i = startIndex, j = size; i < j; i++) { int[] rh; int[] cp; - rh = hiddenColumns.elementAt(i); + rh = hiddenColumns.get(i); if (rh != null) { cp = new int[rh.length]; @@ -683,299 +646,57 @@ public class HiddenColumns return copy; } - /** - * Returns a copy of the vector of hidden regions, as a vector. 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. - * - * @return hidden regions as vector of [start,end] pairs - */ - public Vector getHiddenColumnsCopy() - { - try - { - LOCK.readLock().lock(); - return copyHiddenRegions(); - } finally - { - LOCK.readLock().unlock(); - } - } - - /** - * 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. - * - * @return hidden regions as an ArrayList of [start,end] pairs - */ - public ArrayList getHiddenColumnsCopyAsList() + public String[] getVisibleSequenceStrings(int start, int end, + SequenceI[] seqs) { try { LOCK.readLock().lock(); - return copyHiddenRegionsToArrayList(); - } finally - { - LOCK.readLock().unlock(); - } - } - - /** - * propagate shift in alignment columns to column selection - * - * @param start - * beginning of edit - * @param left - * shift in edit (+ve for removal, or -ve for inserts) - */ - public List compensateForEdit(int start, int change, - ColumnSelection sel) - { - try - { - LOCK.writeLock().lock(); - List deletedHiddenColumns = null; - - if (hiddenColumns != null) + int iSize = seqs.length; + String[] selections = new String[iSize]; + if (hiddenColumns != null && hiddenColumns.size() > 0) { - deletedHiddenColumns = new ArrayList<>(); - int hSize = hiddenColumns.size(); - for (int i = 0; i < hSize; i++) + for (int i = 0; i < iSize; i++) { - int[] region = hiddenColumns.elementAt(i); - if (region[0] > start && start + change > region[1]) - { - deletedHiddenColumns.add(region); - - hiddenColumns.removeElementAt(i); - i--; - hSize--; - continue; - } - - if (region[0] > start) - { - region[0] -= change; - region[1] -= change; - } + StringBuffer visibleSeq = new StringBuffer(); - if (region[0] < 0) + Iterator blocks = new VisibleBlocksIterator(start, + end, false); + while (blocks.hasNext()) { - region[0] = 0; + int[] block = blocks.next(); + visibleSeq.append(seqs[i].getSequence(block[0], block[1])); } + selections[i] = visibleSeq.toString(); + } + } + else + { + for (int i = 0; i < iSize; i++) + { + selections[i] = seqs[i].getSequenceAsString(start, end); } - - this.revealHiddenColumns(0, sel); } - return deletedHiddenColumns; + return selections; } finally { - LOCK.writeLock().unlock(); + LOCK.readLock().unlock(); } } /** - * propagate shift in alignment columns to column selection special version of - * compensateForEdit - allowing for edits within hidden regions + * 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 * - * @param start - * beginning of edit - * @param left - * shift in edit (+ve for removal, or -ve for inserts) + * @param seq + * @return int[] { visible start, visible end, first seqpos, last seqpos, + * alignment index for seq start, alignment index for seq end } */ - public void compensateForDelEdits(int start, int change) - { - try - { - LOCK.writeLock().lock(); - if (hiddenColumns != null) - { - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.elementAt(i); - if (region[0] >= start) - { - region[0] -= change; - } - if (region[1] >= start) - { - region[1] -= change; - } - if (region[1] < region[0]) - { - hiddenColumns.removeElementAt(i--); - } - - if (region[0] < 0) - { - region[0] = 0; - } - if (region[1] < 0) - { - region[1] = 0; - } - } - } - } - finally - { - LOCK.writeLock().unlock(); - } - } - - /** - * return all visible segments between the given start and end boundaries - * - * @param start - * (first column inclusive from 0) - * @param end - * (last column - not inclusive) - * @return int[] {i_start, i_end, ..} where intervals lie in - * start<=i_start<=i_end 0) - { - List visiblecontigs = new ArrayList<>(); - List regions = getHiddenRegions(); - - int vstart = start; - int[] region; - int hideStart; - int hideEnd; - - for (int j = 0; vstart < end && j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; - - if (hideEnd < vstart) - { - continue; - } - if (hideStart > vstart) - { - visiblecontigs.add(new int[] { vstart, hideStart - 1 }); - } - vstart = hideEnd + 1; - } - - if (vstart < end) - { - visiblecontigs.add(new int[] { vstart, end - 1 }); - } - int[] vcontigs = new int[visiblecontigs.size() * 2]; - for (int i = 0, j = visiblecontigs.size(); i < j; i++) - { - int[] vc = visiblecontigs.get(i); - visiblecontigs.set(i, null); - vcontigs[i * 2] = vc[0]; - vcontigs[i * 2 + 1] = vc[1]; - } - visiblecontigs.clear(); - return vcontigs; - } - else - { - return new int[] { start, end - 1 }; - } - } - finally - { - LOCK.readLock().unlock(); - } - } - - public String[] getVisibleSequenceStrings(int start, int end, - SequenceI[] seqs) - { - 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(); - List regions = getHiddenRegions(); - - int blockStart = start; - int blockEnd = end; - int[] region; - int hideStart; - int hideEnd; - - for (int j = 0; j < regions.size(); j++) - { - region = regions.get(j); - 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)); - } - - selections[i] = visibleSeq.toString(); - } - } - else - { - for (int i = 0; i < iSize; i++) - { - selections[i] = seqs[i].getSequenceAsString(start, end); - } - } - - return selections; - } - finally - { - LOCK.readLock().unlock(); - } - } - - /** - * Locate the first 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 - * - * @param seq - * @return int[] { visible start, visible end, first seqpos, last seqpos, - * alignment index for seq start, alignment index for seq end } - */ - public int[] locateVisibleBoundsOfSequence(SequenceI seq) + public int[] locateVisibleBoundsOfSequence(SequenceI seq) { try { @@ -988,15 +709,13 @@ public class HiddenColumns { int ifpos = seq.findIndex(fpos) - 1; int ilpos = seq.findIndex(lpos) - 1; - return new int[] { ifpos, ilpos, fpos, lpos, ifpos, ilpos }; + return new int[] { ifpos, ifpos, ilpos }; } // Simply walk along the sequence whilst watching for hidden column // boundaries - List regions = getHiddenRegions(); + Iterator regions = iterator(); int spos = fpos; - int lastvispos = -1; - int rcount = 0; int hideStart = seq.getLength(); int hideEnd = -1; int visPrev = 0; @@ -1017,9 +736,9 @@ public class HiddenColumns } lastP = p; // update hidden region start/end - while (hideEnd < p && rcount < regions.size()) + while (hideEnd < p && regions.hasNext()) { - int[] region = regions.get(rcount++); + int[] region = regions.next(); visPrev = visNext; visNext += region[0] - visPrev; hideStart = region[0]; @@ -1038,7 +757,6 @@ public class HiddenColumns start = p; foundStart = true; } - lastvispos = p; lpos = spos; } // look for next sequence position @@ -1047,13 +765,11 @@ public class HiddenColumns } if (foundStart) { - return new int[] { findColumnPosition(start), - findColumnPosition(lastvispos), fpos, lpos, firstP, lastP }; + return new int[] { findColumnPosition(start), firstP, lastP }; } // otherwise, sequence was completely hidden - return new int[] { visPrev, visNext, 0, 0, firstP, lastP }; - } - finally + return new int[] { visPrev, firstP, lastP }; + } finally { LOCK.readLock().unlock(); } @@ -1067,7 +783,8 @@ public class HiddenColumns */ public void makeVisibleAnnotation(AlignmentAnnotation alignmentAnnotation) { - makeVisibleAnnotation(-1, -1, alignmentAnnotation); + makeVisibleAnnotation(0, alignmentAnnotation.annotations.length, + alignmentAnnotation); } /** @@ -1087,97 +804,83 @@ public class HiddenColumns 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; - List regions = getHiddenRegions(); - int blockStart = start; - int blockEnd = end; - int[] region; - int hideStart; - int hideEnd; - int w = 0; - - for (int j = 0; j < regions.size(); j++) - { - region = regions.get(j); - hideStart = region[0]; - hideEnd = region[1]; - - if (hideStart < start) - { - continue; - } - blockStart = Math.min(blockStart, hideEnd + 1); - blockEnd = Math.min(blockEnd, hideStart); + int startFrom = start; + int endAt = end; - if (blockStart > blockEnd) - { - break; - } - - annels.addElement(els = new Annotation[blockEnd - blockStart]); - System.arraycopy(alignmentAnnotation.annotations, blockStart, els, - 0, els.length); - w += els.length; - blockStart = hideEnd + 1; - blockEnd = end; - } - - if (end > blockStart) + if (alignmentAnnotation.annotations != null) + { + if (hiddenColumns != null && hiddenColumns.size() > 0) { - annels.addElement(els = new Annotation[end - blockStart + 1]); - 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; + removeHiddenAnnotation(startFrom, endAt, alignmentAnnotation); } - if (w == 0) + else { - return; + alignmentAnnotation.restrict(startFrom, endAt); } + } + } finally + { + LOCK.readLock().unlock(); + } + } - alignmentAnnotation.annotations = new Annotation[w]; - w = 0; - - for (Annotation[] chnk : annels) - { - System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w, - chnk.length); - w += chnk.length; - } + private void removeHiddenAnnotation(int start, int end, + AlignmentAnnotation alignmentAnnotation) + { + // mangle the alignmentAnnotation annotation array + Vector annels = new Vector<>(); + Annotation[] els = null; + + int w = 0; + + Iterator blocks = new VisibleBlocksIterator(start, end, + false); + int copylength; + int annotationLength; + while (blocks.hasNext()) + { + int[] block = blocks.next(); + + if (blocks.hasNext()) + { + annotationLength = block[1] - block[0]; + // copy just the visible segment of the annotation row + copylength = annotationLength; } else { - alignmentAnnotation.restrict(start, end); + annotationLength = block[1] - block[0] + 1; + if (annotationLength + block[0] <= alignmentAnnotation.annotations.length) + { + // copy just the visible segment of the annotation row + copylength = annotationLength; + } + else + { + // copy to the end of the annotation row + copylength = alignmentAnnotation.annotations.length - block[0]; + } } + + els = new Annotation[annotationLength]; + annels.addElement(els); + System.arraycopy(alignmentAnnotation.annotations, block[0], els, 0, + copylength); + w += annotationLength; } - finally + + if (w != 0) { - LOCK.readLock().unlock(); + alignmentAnnotation.annotations = new Annotation[w]; + + w = 0; + for (Annotation[] chnk : annels) + { + System.arraycopy(chnk, 0, alignmentAnnotation.annotations, w, + chnk.length); + w += chnk.length; + } } } @@ -1227,7 +930,7 @@ public class HiddenColumns List inserts = sr.getInsertions(); for (int[] r : inserts) { - hideColumns(r[0], r[1], true); + hideColumns(r[0], r[1]); } } finally { @@ -1247,7 +950,7 @@ public class HiddenColumns { for (int i = 0; i < hiddenColumns.size(); i++) { - int[] region = hiddenColumns.elementAt(i); + int[] region = hiddenColumns.get(i); for (int j = region[0]; j < region[1] + 1; j++) { sel.addElement(j); @@ -1256,8 +959,7 @@ public class HiddenColumns } hiddenColumns = null; - } - finally + } finally { LOCK.writeLock().unlock(); } @@ -1276,7 +978,7 @@ public class HiddenColumns LOCK.writeLock().lock(); for (int i = 0; i < hiddenColumns.size(); i++) { - int[] region = hiddenColumns.elementAt(i); + int[] region = hiddenColumns.get(i); if (start == region[0]) { for (int j = region[0]; j < region[1] + 1; j++) @@ -1284,7 +986,7 @@ public class HiddenColumns sel.addElement(j); } - hiddenColumns.removeElement(region); + hiddenColumns.remove(region); break; } } @@ -1292,133 +994,7 @@ public class HiddenColumns { hiddenColumns = null; } - } - finally - { - LOCK.writeLock().unlock(); - } - } - - /** - * removes intersection of position,length ranges in deletions from the - * start,end regions marked in intervals. - * - * @param shifts - * @param intervals - * @return - */ - private boolean pruneIntervalVector(final List shifts, - Vector intervals) - { - boolean pruned = false; - int i = 0; - int j = intervals.size() - 1; - int s = 0; - int t = shifts.size() - 1; - int hr[] = intervals.elementAt(i); - int sr[] = shifts.get(s); - while (i <= j && s <= t) - { - boolean trailinghn = hr[1] >= sr[0]; - if (!trailinghn) - { - if (i < j) - { - hr = intervals.elementAt(++i); - } - else - { - i++; - } - continue; - } - int endshift = sr[0] + sr[1]; // deletion ranges - -ve means an insert - if (endshift < hr[0] || endshift < sr[0]) - { // leadinghc disjoint or not a deletion - if (s < t) - { - sr = shifts.get(++s); - } - else - { - s++; - } - continue; - } - boolean leadinghn = hr[0] >= sr[0]; - boolean leadinghc = hr[0] < endshift; - boolean trailinghc = hr[1] < endshift; - if (leadinghn) - { - if (trailinghc) - { // deleted hidden region. - intervals.removeElementAt(i); - pruned = true; - j--; - if (i <= j) - { - hr = intervals.elementAt(i); - } - continue; - } - if (leadinghc) - { - hr[0] = endshift; // clip c terminal region - leadinghn = !leadinghn; - pruned = true; - } - } - if (!leadinghn) - { - if (trailinghc) - { - if (trailinghn) - { - hr[1] = sr[0] - 1; - pruned = true; - } - } - else - { - // sr contained in hr - if (s < t) - { - sr = shifts.get(++s); - } - else - { - s++; - } - continue; - } - } - } - return pruned; // true if any interval was removed or modified by - // operations. - } - - /** - * remove any hiddenColumns or selected columns and shift remaining based on a - * series of position, range deletions. - * - * @param deletions - */ - public void pruneDeletions(List shifts) - { - try - { - LOCK.writeLock().lock(); - // delete any intervals intersecting. - if (hiddenColumns != null) - { - pruneIntervalVector(shifts, hiddenColumns); - if (hiddenColumns != null && hiddenColumns.size() == 0) - { - hiddenColumns = null; - } - } - } - finally + } finally { LOCK.writeLock().unlock(); } @@ -1463,155 +1039,124 @@ public class HiddenColumns private void propagateInsertions(SequenceI profileseq, AlignmentI al, SequenceI origseq) { - char gc = al.getGapCharacter(); - // recover mapping between sequence's non-gap positions and positions - // mapping to view. - pruneDeletions(ShiftList.parseMap(origseq.gapMap())); - int[] viscontigs = al.getHiddenColumns().getVisibleContigs(0, - profileseq.getLength()); - int spos = 0; - int offset = 0; - - // add profile to visible contigs - for (int v = 0; v < viscontigs.length; v += 2) + try { - if (viscontigs[v] > spos) + LOCK.writeLock().lock(); + + char gc = al.getGapCharacter(); + + // take the set of hidden columns, and the set of gaps in origseq, + // and remove all the hidden gaps from hiddenColumns + + // first get the 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, ns = viscontigs[v] - spos; s < ns; s++) + for (int s = 0; s < right - left + 1; s++) { sb.append(gc); } - 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() <= spos + offset) - { - // pad sequence - int diff = spos + offset - sq.length() - 1; - if (diff > 0) - { - // pad gaps - sq = sq + sb; - while ((diff = spos + offset - sq.length() - 1) > 0) - { - // sq = sq - // + ((diff >= sb.length()) ? sb.toString() : sb - // .substring(0, diff)); - 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, spos + offset) + sb.toString() - + sq.substring(spos + offset)); - } - } - } - // offset+=sb.length(); - } - spos = viscontigs[v + 1] + 1; - } - if ((offset + spos) < profileseq.getLength()) - { - // pad the final region with gaps. - StringBuffer sb = new StringBuffer(); - for (int s = 0, ns = profileseq.getLength() - spos - offset; s < ns; s++) - { - sb.append(gc); - } - for (int s = 0, ns = al.getHeight(); s < ns; s++) - { - SequenceI sqobj = al.getSequenceAt(s); - if (sqobj == profileseq) - { - continue; - } - String sq = sqobj.getSequenceAsString(); - // pad sequence - int diff = origseq.getLength() - sq.length(); - while (diff > 0) - { - // sq = sq - // + ((diff >= sb.length()) ? sb.toString() : sb - // .substring(0, diff)); - if (diff >= sb.length()) - { - sq += sb.toString(); - } - else - { - char[] buf = new char[diff]; - sb.getChars(0, diff, buf, 0); - sq += buf.toString(); - } - diff = origseq.getLength() - sq.length(); - } - } - } - } - - /** - * remove any hiddenColumns or selected columns and shift remaining based on a - * series of position, range deletions. - * - * @param deletions - */ - private void pruneDeletions(ShiftList deletions) - { - if (deletions != null) - { - final List shifts = deletions.getShifts(); - if (shifts != null && shifts.size() > 0) - { - pruneDeletions(shifts); + padGaps(sb, left, profileseq, al); - // and shift the rest. - this.compensateForEdits(deletions); } + hiddenColumns = newhidden; + } finally + { + LOCK.writeLock().unlock(); } } /** - * Adjust hidden column boundaries based on a series of column additions or - * deletions in visible regions. + * Pad gaps in all sequences in alignment except profileseq * - * @param shiftrecord - * @return + * @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 ShiftList compensateForEdits(ShiftList shiftrecord) + private void padGaps(StringBuffer sb, int pos, SequenceI profileseq, + AlignmentI al) { - if (shiftrecord != null) + // loop over the sequences and pad with gaps where required + for (int s = 0, ns = al.getHeight(); s < ns; s++) { - final List shifts = shiftrecord.getShifts(); - if (shifts != null && shifts.size() > 0) + SequenceI sqobj = al.getSequenceAt(s); + if (sqobj != profileseq) { - int shifted = 0; - for (int i = 0, j = shifts.size(); i < j; i++) + String sq = al.getSequenceAt(s).getSequenceAsString(); + if (sq.length() <= pos) { - int[] sh = shifts.get(i); - compensateForDelEdits(shifted + sh[0], sh[1]); - shifted -= sh[1]; + // 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)); } } - return shiftrecord.getInverse(); } - return null; } /** @@ -1628,13 +1173,12 @@ public class HiddenColumns { for (int[] hidden : hiddenColumns) { - hashCode = 31 * hashCode + hidden[0]; - hashCode = 31 * hashCode + hidden[1]; + hashCode = HASH_MULTIPLIER * hashCode + hidden[0]; + hashCode = HASH_MULTIPLIER * hashCode + hidden[1]; } } return hashCode; - } - finally + } finally { LOCK.readLock().unlock(); } @@ -1656,7 +1200,7 @@ public class HiddenColumns .nextSetBit(lastSet)) { lastSet = inserts.nextClearBit(firstSet); - hideColumns(firstSet, lastSet - 1, true); + hideColumns(firstSet, lastSet - 1); } } finally { @@ -1682,8 +1226,7 @@ public class HiddenColumns { inserts.set(range[0], range[1] + 1); } - } - finally + } finally { LOCK.readLock().unlock(); } @@ -1777,4 +1320,715 @@ public class HiddenColumns } } + /** + * Return an iterator over the hidden regions + */ + 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 a bounded iterator over the hidden regions + * + * @param start + * position to start from (inclusive, absolute column position) + * @param end + * position to end at (inclusive, absolute column position) + * @return + */ + public Iterator getBoundedIterator(int start, int end) + { + return new BoundedHiddenColsIterator(start, end, true); + } + + /** + * Return a bounded iterator over the *visible* start positions of hidden + * regions + * + * @param start + * position to start from (inclusive, visible column position) + * @param end + * position to end at (inclusive, visible column position) + */ + public Iterator getBoundedStartIterator(int start, int end) + { + return new BoundedStartRegionIterator(start, end, true); + } + + /** + * Return an iterator over visible columns between the given start and end + * boundaries + * + * @param start + * first column (inclusive) + * @param end + * last column (inclusive) + */ + public Iterator getVisibleColsIterator(int start, int end) + { + return new VisibleColsIterator(start, end, true); + } + + /** + * 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) + */ + public Iterator getVisContigsIterator(int start, int end) + { + return new VisibleContigsIterator(start, end, true); + } + + /** + * return an iterator over visible segments between the given start and end + * boundaries + * + * @param start + * (first column - inclusive from 0) + * @param end + * (last column - inclusive) + * @param useVisibleCoords + * if true, start and end are visible column positions, not absolute + * positions + */ + public Iterator getVisibleBlocksIterator(int start, int end, + boolean useVisibleCoords) + { + if (useVisibleCoords) + { + // TODO + // we should really just convert start and end here with + // adjustForHiddenColumns + // and then create a VisibleBlocksIterator + // 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); + } + } + + /** + * An iterator which iterates over hidden column regions in a range. + */ + private 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; + } + } + + /** + * An iterator which iterates over visible start positions of hidden column + * regions in a range. + */ + private class BoundedStartRegionIterator 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; + + // 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()); + } + + /** + * Get next hidden region start position + * + * @return the start position in *visible* coordinates + */ + @Override + public Integer next() + { + int result = positions.get(currentPosition); + currentPosition++; + return result; + } + } + + private class VisibleColsIterator implements Iterator + { + private int last; + + private int current; + + private int next; + + private List localHidden = new ArrayList<>(); + + private int nexthiddenregion; + + VisibleColsIterator(int firstcol, int lastcol, boolean useCopy) + { + 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(); + } + + if (hiddenColumns != null) + { + 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 (last >= hiddenColumns.get(i)[0] + && last <= hiddenColumns.get(i)[1]) + { + // last is hidden, move to left + last = hiddenColumns.get(i)[0] - 1; + } + } + + // make a local copy of the bit we need + i = nexthiddenregion; + while (i < hiddenColumns.size() + && hiddenColumns.get(i)[0] <= last) + { + int[] region = new int[] { hiddenColumns.get(i)[0], + hiddenColumns.get(i)[1] }; + localHidden.add(region); + i++; + } + } + } finally + { + if (useCopy) + { + LOCK.readLock().unlock(); + } + } + } + + @Override + public boolean hasNext() + { + return next <= last; + } + + @Override + public Integer next() + { + if (next > last) + { + throw new NoSuchElementException(); + } + current = next; + if ((localHidden != null) + && (nexthiddenregion < localHidden.size())) + { + // still some more hidden regions + if (next + 1 < localHidden.get(nexthiddenregion)[0]) + { + // next+1 is still before the next hidden region + next++; + } + else if ((next + 1 >= localHidden.get(nexthiddenregion)[0]) + && (next + 1 <= localHidden.get(nexthiddenregion)[1])) + { + // next + 1 is in the next hidden region + next = localHidden.get(nexthiddenregion)[1] + 1; + nexthiddenregion++; + } + } + else + { + // finished with hidden regions, just increment normally + next++; + } + return current; + } + + @Override + public void remove() + { + throw new UnsupportedOperationException(); + } + } + + /** + * An iterator which iterates over visible regions in a range. + */ + private class VisibleContigsIterator implements Iterator + { + private List vcontigs = new ArrayList<>(); + + private int currentPosition = 0; + + VisibleContigsIterator(int start, int end, boolean usecopy) + { + try + { + if (usecopy) + { + LOCK.readLock().lock(); + } + + if (hiddenColumns != null && hiddenColumns.size() > 0) + { + int vstart = start; + int hideStart; + int hideEnd; + + for (int[] region : hiddenColumns) + { + hideStart = region[0]; + hideEnd = region[1]; + + // navigate to start + if (hideEnd < vstart) + { + continue; + } + if (hideStart > vstart) + { + int[] contig = new int[] { vstart, hideStart - 1 }; + vcontigs.add(contig); + } + vstart = hideEnd + 1; + + // exit if we're past the end + if (vstart >= end) + { + break; + } + } + + if (vstart < end) + { + int[] contig = new int[] { vstart, end - 1 }; + vcontigs.add(contig); + } + } + else + { + int[] contig = new int[] { start, end - 1 }; + 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. + */ + 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 as visible + * column positions. + */ + public class VisibleBlocksVisBoundsIterator implements Iterator + { + private List vcontigs = new ArrayList<>(); + + private int currentPosition = 0; + + private boolean endsAtHidden = false; + + VisibleBlocksVisBoundsIterator(int start, int end, boolean usecopy) + { + try + { + if (usecopy) + { + LOCK.readLock().lock(); + } + + if (hiddenColumns != null && hiddenColumns.size() > 0) + { + int blockStart = start; + int blockEnd = end; + int hiddenSoFar = 0; + int visSoFar = 0; + endsAtHidden = false; + + // iterate until a region begins within (start,end] + int i = 0; + while ((i < hiddenColumns.size()) + && (hiddenColumns.get(i)[0] <= blockStart + hiddenSoFar)) + { + hiddenSoFar += hiddenColumns.get(i)[1] - hiddenColumns.get(i)[0] + + 1; + i++; + } + + blockStart += hiddenSoFar; // convert start to absolute position + blockEnd += hiddenSoFar; // convert end too in + + // 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] <= blockEnd)) + { + int[] region = hiddenColumns.get(i); + + blockEnd = Math.min(blockEnd, region[0] - 1); + + int[] contig = new int[] { blockStart, blockEnd }; + vcontigs.add(contig); + + visSoFar += blockEnd - blockStart + 1; + blockStart = region[1] + 1; + + hiddenSoFar += region[1] - region[0] + 1; + blockEnd = end + hiddenSoFar; + + i++; + } + if (visSoFar < end - start) + { + blockEnd = blockStart + end - start - visSoFar; + int[] contig = new int[] { blockStart, blockEnd }; + vcontigs.add(contig); + + if (i < hiddenColumns.size() + && hiddenColumns.get(i)[0] - 1 == blockEnd) + { + endsAtHidden = true; + } + } + } + else + { + // there are no hidden columns, return a single visible contig + int[] contig = new int[] { start, end }; + vcontigs.add(contig); + endsAtHidden = false; + } + } 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; + } + + public boolean endsAtHidden() + { + return endsAtHidden; + } + } + }