X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fdatamodel%2FHiddenColumns.java;h=c0a43eea64ba09df70ed8e5686e58334ecb772f0;hb=c854dfdb52d94eafd259846aaa242c79ea0753c7;hp=1e1a58bd61037e14c904c732c00621fba7d827ed;hpb=1c251a57c7b2fb70dabceb480d0170363357558f;p=jalview.git diff --git a/src/jalview/datamodel/HiddenColumns.java b/src/jalview/datamodel/HiddenColumns.java index 1e1a58b..c0a43ee 100644 --- a/src/jalview/datamodel/HiddenColumns.java +++ b/src/jalview/datamodel/HiddenColumns.java @@ -1,3 +1,23 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.datamodel; import jalview.util.Comparison; @@ -6,74 +26,119 @@ 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.Vector; import java.util.concurrent.locks.ReentrantReadWriteLock; -public class HiddenColumns implements Iterable +public class HiddenColumns { - private static final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); - + 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; /** - * This Method is used to return all the HiddenColumn regions + * 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(); + } + } + } finally + { + LOCK.writeLock().unlock(); + } + } + + /** + * 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. * * @return empty list or List of hidden column intervals */ - public List getHiddenRegions() + private List getHiddenRegions() { return hiddenColumns == null ? Collections. emptyList() : hiddenColumns; } /** - * Find the number of hidden columns + * Output regions data as a string. String is in the format: + * reg0[0]reg0[1]reg1[0]reg1[1] ... regn[1] * - * @return number of hidden columns + * @param delimiter + * string to delimit regions + * @param betweenstring + * to put between start and end region values + * @return regions formatted according to delimiter and between strings */ - public int getSize() + public String regionsToString(String delimiter, String between) { try { - lock.readLock().lock(); - int size = 0; - if (hasHidden()) + LOCK.readLock().lock(); + StringBuilder regionBuilder = new StringBuilder(); + if (hiddenColumns != null) { for (int[] range : hiddenColumns) { - size += range[1] - range[0] + 1; + regionBuilder.append(delimiter).append(range[0]).append(between) + .append(range[1]); } + + regionBuilder.deleteCharAt(0); } - return size; - } - finally + return regionBuilder.toString(); + } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } /** - * Answers if there are any hidden columns + * Find the number of hidden columns * - * @return true if there are hidden columns + * @return number of hidden columns */ - public boolean hasHidden() + public int getSize() { try { - lock.readLock().lock(); - return (hiddenColumns != null) && (!hiddenColumns.isEmpty()); + LOCK.readLock().lock(); + int size = 0; + if (hasHiddenColumns()) + { + for (int[] range : hiddenColumns) + { + size += range[1] - range[0] + 1; + } + } + return size; } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } - } @Override @@ -81,7 +146,7 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); if (!(obj instanceof HiddenColumns)) { @@ -113,7 +178,7 @@ public class HiddenColumns implements Iterable return true; } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -128,13 +193,13 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); int result = column; if (hiddenColumns != null) { 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; @@ -144,7 +209,7 @@ public class HiddenColumns implements Iterable return result; } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -161,7 +226,7 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); int result = hiddenColumn; if (hiddenColumns != null) { @@ -169,7 +234,7 @@ public class HiddenColumns implements Iterable int[] region; do { - region = hiddenColumns.elementAt(index++); + region = hiddenColumns.get(index++); if (hiddenColumn > region[1]) { result -= region[1] + 1 - region[0]; @@ -203,7 +268,7 @@ public class HiddenColumns implements Iterable // columns. } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -223,51 +288,51 @@ public class HiddenColumns implements Iterable try { - lock.readLock().lock(); - int distance = visibleDistance; + LOCK.readLock().lock(); + 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(); + LOCK.readLock().unlock(); } } @@ -281,37 +346,44 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); - List positions = new ArrayList<>( - hiddenColumns.size()); + LOCK.readLock().lock(); + List positions = null; - positions.add(hiddenColumns.elementAt(0)[0]); - for (int i = 1; i < hiddenColumns.size(); ++i) + if (hiddenColumns != null) { + positions = new ArrayList<>(hiddenColumns.size()); - int result = 0; - if (hiddenColumns != null) + positions.add(hiddenColumns.get(0)[0]); + for (int i = 1; i < hiddenColumns.size(); ++i) { - int index = 0; - int gaps = 0; - do + + int result = 0; + if (hiddenColumns != null) { - int[] region = hiddenColumns.elementAt(index); - gaps += region[1] + 1 - region[0]; - result = region[1] + 1; - index++; - } while (index <= i); + int index = 0; + int gaps = 0; + do + { + int[] region = hiddenColumns.get(index); + gaps += region[1] + 1 - region[0]; + result = region[1] + 1; + index++; + } while (index <= i); - result -= gaps; + result -= gaps; + } + positions.add(result); } - positions.add(result); + } + else + { + positions = new ArrayList<>(); } return positions; - } - finally + } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -326,13 +398,13 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); if (hiddenColumns != null) { int index = 0; do { - int[] region = hiddenColumns.elementAt(index); + int[] region = hiddenColumns.get(index); if (alPos < region[0]) { return region[0]; @@ -345,7 +417,7 @@ public class HiddenColumns implements Iterable return alPos; } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -361,27 +433,27 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + 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(); + LOCK.readLock().unlock(); } } @@ -398,26 +470,26 @@ public class HiddenColumns implements Iterable try { - lock.readLock().lock(); - if (hiddenColumns != null) - { - int index = hiddenColumns.size() - 1; - do + LOCK.readLock().lock(); + 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(); + LOCK.readLock().unlock(); } } @@ -430,96 +502,91 @@ public class HiddenColumns implements Iterable */ 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(); + LOCK.writeLock().lock(); } - - if (hiddenColumns == null) - { - hiddenColumns = new Vector<>(); - } - - /* - * traverse existing hidden ranges and insert / amend / append as - * appropriate - */ - for (int i = 0; i < hiddenColumns.size(); i++) - { - int[] region = hiddenColumns.elementAt(i); - - if (end < region[0] - 1) + else { - /* - * insert discontiguous preceding range - */ - hiddenColumns.insertElementAt(new int[] { start, end }, i); - return; + wasAlreadyLocked = true; } - if (end <= region[1]) + if (hiddenColumns == null) { - /* - * new range overlaps existing, or is contiguous preceding it - adjust - * start column - */ - region[0] = Math.min(region[0], start); - return; + hiddenColumns = new ArrayList<>(); } - if (start <= region[1] + 1) + /* + * traverse existing hidden ranges and insert / amend / append as + * appropriate + */ + for (int i = 0; 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[] 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]) { - int[] nextRegion = hiddenColumns.get(i + 1); - if (nextRegion[0] > end + 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) { - /* - * gap to next hidden range - no more to update - */ - break; + 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); } - region[1] = Math.max(nextRegion[1], end); - hiddenColumns.remove(i + 1); + return; } - 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(); + LOCK.writeLock().unlock(); } } } @@ -528,82 +595,40 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + 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(); + 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() + private ArrayList copyHiddenRegionsToArrayList() { - Vector copy = new Vector<>(hiddenColumns.size()); - for (int i = 0, j = hiddenColumns.size(); i < j; i++) + int size = 0; + if (hiddenColumns != null) { - int[] rh, cp; - rh = hiddenColumns.elementAt(i); - if (rh != null) - { - cp = new int[rh.length]; - System.arraycopy(rh, 0, cp, 0, rh.length); - copy.addElement(cp); - } + size = hiddenColumns.size(); } - return copy; - } + ArrayList copy = new ArrayList<>(size); - private ArrayList copyHiddenRegionsToArrayList() - { - ArrayList copy = new ArrayList<>(hiddenColumns.size()); - for (int i = 0, j = hiddenColumns.size(); i < j; i++) + for (int i = 0, j = size; i < j; i++) { - int[] rh, cp; - rh = hiddenColumns.elementAt(i); + int[] rh; + int[] cp; + rh = hiddenColumns.get(i); if (rh != null) { cp = new int[rh.length]; @@ -611,30 +636,27 @@ public class HiddenColumns implements Iterable copy.add(cp); } } - return copy; - } - public void getHiddenColumnsCopy(Vector copy) - { - try - { - lock.readLock().lock(); - copy = copyHiddenRegions(); - } finally - { - lock.readLock().unlock(); - } + return copy; } - public void getHiddenColumnsCopy(ArrayList 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. + * + * @return hidden regions as an ArrayList of [start,end] pairs + */ + public ArrayList getHiddenColumnsCopy() { try { - lock.readLock().lock(); - copy = copyHiddenRegionsToArrayList(); + LOCK.readLock().lock(); + return copyHiddenRegionsToArrayList(); } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -651,7 +673,7 @@ public class HiddenColumns implements Iterable { try { - lock.writeLock().lock(); + LOCK.writeLock().lock(); List deletedHiddenColumns = null; if (hiddenColumns != null) @@ -660,12 +682,12 @@ public class HiddenColumns implements Iterable int hSize = hiddenColumns.size(); for (int i = 0; i < hSize; i++) { - int[] region = hiddenColumns.elementAt(i); + int[] region = hiddenColumns.get(i); if (region[0] > start && start + change > region[1]) { deletedHiddenColumns.add(region); - hiddenColumns.removeElementAt(i); + hiddenColumns.remove(i); i--; hSize--; continue; @@ -690,7 +712,7 @@ public class HiddenColumns implements Iterable return deletedHiddenColumns; } finally { - lock.writeLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -707,12 +729,12 @@ public class HiddenColumns implements Iterable { try { - lock.writeLock().lock(); + LOCK.writeLock().lock(); if (hiddenColumns != null) { for (int i = 0; i < hiddenColumns.size(); i++) { - int[] region = hiddenColumns.elementAt(i); + int[] region = hiddenColumns.get(i); if (region[0] >= start) { region[0] -= change; @@ -723,7 +745,7 @@ public class HiddenColumns implements Iterable } if (region[1] < region[0]) { - hiddenColumns.removeElementAt(i--); + hiddenColumns.remove(i--); } if (region[0] < 0) @@ -736,10 +758,9 @@ public class HiddenColumns implements Iterable } } } - } - finally + } finally { - lock.writeLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -757,7 +778,7 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); if (hiddenColumns != null && hiddenColumns.size() > 0) { List visiblecontigs = new ArrayList<>(); @@ -765,7 +786,8 @@ public class HiddenColumns implements Iterable int vstart = start; int[] region; - int hideStart, hideEnd; + int hideStart; + int hideEnd; for (int j = 0; vstart < end && j < regions.size(); j++) { @@ -803,10 +825,9 @@ public class HiddenColumns implements Iterable { return new int[] { start, end - 1 }; } - } - finally + } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -815,19 +836,21 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); - int i, iSize = seqs.length; - String selections[] = new String[iSize]; + LOCK.readLock().lock(); + int iSize = seqs.length; + String[] selections = new String[iSize]; if (hiddenColumns != null && hiddenColumns.size() > 0) { - for (i = 0; i < iSize; i++) + for (int i = 0; i < iSize; i++) { StringBuffer visibleSeq = new StringBuffer(); List regions = getHiddenRegions(); - int blockStart = start, blockEnd = end; + int blockStart = start; + int blockEnd = end; int[] region; - int hideStart, hideEnd; + int hideStart; + int hideEnd; for (int j = 0; j < regions.size(); j++) { @@ -864,17 +887,16 @@ public class HiddenColumns implements Iterable } else { - for (i = 0; i < iSize; i++) + for (int i = 0; i < iSize; i++) { selections[i] = seqs[i].getSequenceAsString(start, end); } } return selections; - } - finally + } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -892,23 +914,30 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); - int fpos = seq.getStart(), lpos = seq.getEnd(); + 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, - ilpos = seq.findIndex(lpos) - 1; + int ifpos = seq.findIndex(fpos) - 1; + int ilpos = seq.findIndex(lpos) - 1; return new int[] { ifpos, ilpos, fpos, lpos, ifpos, ilpos }; } // Simply walk along the sequence whilst watching for hidden column // boundaries List regions = getHiddenRegions(); - int spos = fpos, lastvispos = -1, rcount = 0, - hideStart = seq.getLength(), hideEnd = -1; - int visPrev = 0, visNext = 0, firstP = -1, lastP = -1; + int spos = fpos; + int lastvispos = -1; + 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++) @@ -958,10 +987,9 @@ public class HiddenColumns implements Iterable } // otherwise, sequence was completely hidden return new int[] { visPrev, visNext, 0, 0, firstP, lastP }; - } - finally + } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -992,7 +1020,7 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); if (alignmentAnnotation.annotations == null) { return; @@ -1008,9 +1036,12 @@ public class HiddenColumns implements Iterable Vector annels = new Vector<>(); Annotation[] els = null; List regions = getHiddenRegions(); - int blockStart = start, blockEnd = end; + int blockStart = start; + int blockEnd = end; int[] region; - int hideStart, hideEnd, w = 0; + int hideStart; + int hideEnd; + int w = 0; for (int j = 0; j < regions.size(); j++) { @@ -1077,10 +1108,9 @@ public class HiddenColumns implements Iterable { alignmentAnnotation.restrict(start, end); } - } - finally + } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -1092,11 +1122,11 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); return hiddenColumns != null && hiddenColumns.size() > 0; } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -1108,11 +1138,11 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); return hiddenColumns != null && hiddenColumns.size() > 1; } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -1126,15 +1156,15 @@ public class HiddenColumns implements Iterable { try { - lock.writeLock().lock(); + LOCK.writeLock().lock(); List inserts = sr.getInsertions(); for (int[] r : inserts) { - hideColumns(r[0], r[1], true); + hideColumns(r[0], r[1]); } } finally { - lock.writeLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -1145,12 +1175,12 @@ public class HiddenColumns implements Iterable { try { - lock.writeLock().lock(); + LOCK.writeLock().lock(); if (hiddenColumns != null) { 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); @@ -1159,10 +1189,9 @@ public class HiddenColumns implements Iterable } hiddenColumns = null; - } - finally + } finally { - lock.writeLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -1176,10 +1205,10 @@ public class HiddenColumns implements Iterable { try { - lock.writeLock().lock(); + 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++) @@ -1187,7 +1216,7 @@ public class HiddenColumns implements Iterable sel.addElement(j); } - hiddenColumns.removeElement(region); + hiddenColumns.remove(region); break; } } @@ -1195,10 +1224,9 @@ public class HiddenColumns implements Iterable { hiddenColumns = null; } - } - finally + } finally { - lock.writeLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -1210,13 +1238,16 @@ public class HiddenColumns implements Iterable * @param intervals * @return */ - private boolean pruneIntervalVector(final List shifts, - Vector intervals) + private boolean pruneIntervalList(final List shifts, + ArrayList intervals) { boolean pruned = false; - int i = 0, j = intervals.size() - 1, s = 0, t = shifts.size() - 1; - int hr[] = intervals.elementAt(i); - int sr[] = shifts.get(s); + int i = 0; + int j = intervals.size() - 1; + int s = 0; + int t = shifts.size() - 1; + int[] hr = intervals.get(i); + int[] sr = shifts.get(s); while (i <= j && s <= t) { boolean trailinghn = hr[1] >= sr[0]; @@ -1224,7 +1255,7 @@ public class HiddenColumns implements Iterable { if (i < j) { - hr = intervals.elementAt(++i); + hr = intervals.get(++i); } else { @@ -1252,12 +1283,12 @@ public class HiddenColumns implements Iterable { if (trailinghc) { // deleted hidden region. - intervals.removeElementAt(i); + intervals.remove(i); pruned = true; j--; if (i <= j) { - hr = intervals.elementAt(i); + hr = intervals.get(i); } continue; } @@ -1307,20 +1338,19 @@ public class HiddenColumns implements Iterable { try { - lock.writeLock().lock(); + LOCK.writeLock().lock(); // delete any intervals intersecting. if (hiddenColumns != null) { - pruneIntervalVector(shifts, hiddenColumns); + pruneIntervalList(shifts, hiddenColumns); if (hiddenColumns != null && hiddenColumns.size() == 0) { hiddenColumns = null; } } - } - finally + } finally { - lock.writeLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -1367,8 +1397,7 @@ public class HiddenColumns implements Iterable // 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[] viscontigs = getVisibleContigs(0, profileseq.getLength()); int spos = 0; int offset = 0; @@ -1417,9 +1446,8 @@ public class HiddenColumns implements Iterable } else { - al.getSequenceAt(s).setSequence( - sq.substring(0, spos + offset) + sb.toString() - + sq.substring(spos + offset)); + al.getSequenceAt(s).setSequence(sq.substring(0, spos + offset) + + sb.toString() + sq.substring(spos + offset)); } } } @@ -1431,7 +1459,8 @@ public class HiddenColumns implements Iterable { // pad the final region with gaps. StringBuffer sb = new StringBuffer(); - for (int s = 0, ns = profileseq.getLength() - spos - offset; s < ns; s++) + for (int s = 0, ns = profileseq.getLength() - spos + - offset; s < ns; s++) { sb.append(gc); } @@ -1522,7 +1551,7 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); int hashCode = 1; if (hiddenColumns != null) { @@ -1533,10 +1562,9 @@ public class HiddenColumns implements Iterable } } return hashCode; - } - finally + } finally { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } } @@ -1550,17 +1578,17 @@ public class HiddenColumns implements Iterable { try { - lock.writeLock().lock(); + 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, true); + hideColumns(firstSet, lastSet - 1); } } finally { - lock.writeLock().unlock(); + LOCK.writeLock().unlock(); } } @@ -1573,7 +1601,7 @@ public class HiddenColumns implements Iterable { try { - lock.readLock().lock(); + LOCK.readLock().lock(); if (hiddenColumns == null) { return; @@ -1582,21 +1610,98 @@ public class HiddenColumns implements Iterable { inserts.set(range[0], range[1] + 1); } + } finally + { + LOCK.readLock().unlock(); } - finally + } + + /** + * 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) + { + 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 { - lock.readLock().unlock(); + LOCK.readLock().unlock(); } + } - @Override - public Iterator iterator() + /** + * 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) { - if (hiddenColumns == null) + 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; + } finally { - return Collections. emptyList().iterator(); + LOCK.readLock().unlock(); } - return hiddenColumns.iterator(); } }