* list of hidden column [start, end] ranges; the list is maintained in
* ascending start column order
*/
- private Vector<int[]> hiddenColumns;
+ private ArrayList<int[]> 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<int[]> getHiddenRegions()
+ private List<int[]> getHiddenRegions()
{
return hiddenColumns == null ? Collections.<int[]> emptyList()
: hiddenColumns;
{
LOCK.readLock().lock();
int size = 0;
- if (hasHidden())
+ if (hasHiddenColumns())
{
for (int[] range : hiddenColumns)
{
}
}
- /**
- * Answers if there are any hidden columns
- *
- * @return true if there are hidden columns
- */
- public boolean hasHidden()
- {
- try
- {
- LOCK.readLock().lock();
- return (hiddenColumns != null) && (!hiddenColumns.isEmpty());
- } finally
- {
- LOCK.readLock().unlock();
- }
-
- }
-
@Override
public boolean equals(Object obj)
{
{
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;
int[] region;
do
{
- region = hiddenColumns.elementAt(index++);
+ region = hiddenColumns.get(index++);
if (hiddenColumn > region[1])
{
result -= region[1] + 1 - region[0];
{
positions = new ArrayList<>(hiddenColumns.size());
- positions.add(hiddenColumns.elementAt(0)[0]);
+ positions.add(hiddenColumns.get(0)[0]);
for (int i = 1; i < hiddenColumns.size(); ++i)
{
int gaps = 0;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
gaps += region[1] + 1 - region[0];
result = region[1] + 1;
index++;
int index = 0;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
if (alPos < region[0])
{
return region[0];
int index = hiddenColumns.size() - 1;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
if (alPos > region[1])
{
return region[1];
int index = hiddenColumns.size() - 1;
do
{
- int[] region = hiddenColumns.elementAt(index);
+ int[] region = hiddenColumns.get(index);
if (pos > region[1])
{
return index;
*/
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<>();
}
/*
*/
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;
}
/*
* remaining case is that the new range follows everything else
*/
- hiddenColumns.addElement(new int[] { start, end });
+ hiddenColumns.add(new int[] { start, end });
} finally
{
- if (!alreadyLocked)
+ if (!wasAlreadyLocked)
{
LOCK.writeLock().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<int[]> copyHiddenRegions()
+ private ArrayList<int[]> copyHiddenRegionsToArrayList()
{
- Vector<int[]> copy = new Vector<>(hiddenColumns.size());
- for (int i = 0, j = hiddenColumns.size(); i < j; i++)
+ int size = 0;
+ if (hiddenColumns != null)
{
- 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);
- }
+ size = hiddenColumns.size();
}
- return copy;
- }
+ ArrayList<int[]> copy = new ArrayList<>(size);
- private ArrayList<int[]> copyHiddenRegionsToArrayList()
- {
- ArrayList<int[]> 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;
int[] cp;
- rh = hiddenColumns.elementAt(i);
+ rh = hiddenColumns.get(i);
if (rh != null)
{
cp = new int[rh.length];
copy.add(cp);
}
}
- 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<int[]> getHiddenColumnsCopy()
- {
- try
- {
- LOCK.readLock().lock();
- return copyHiddenRegions();
- } finally
- {
- LOCK.readLock().unlock();
- }
+ return copy;
}
-
+
/**
* Returns a copy of the vector of hidden regions, as an ArrayList. Before
* using this method please consider if you really need access to the hidden
*
* @return hidden regions as an ArrayList of [start,end] pairs
*/
- public ArrayList<int[]> getHiddenColumnsCopyAsList()
+ public ArrayList<int[]> getHiddenColumnsCopy()
{
try
{
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;
{
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;
}
if (region[1] < region[0])
{
- hiddenColumns.removeElementAt(i--);
+ hiddenColumns.remove(i--);
}
if (region[0] < 0)
{
LOCK.readLock().lock();
int iSize = seqs.length;
- String selections[] = new String[iSize];
+ String[] selections = new String[iSize];
if (hiddenColumns != null && hiddenColumns.size() > 0)
{
for (int i = 0; i < iSize; i++)
List<int[]> inserts = sr.getInsertions();
for (int[] r : inserts)
{
- hideColumns(r[0], r[1], true);
+ hideColumns(r[0], r[1]);
}
} finally
{
{
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);
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++)
sel.addElement(j);
}
- hiddenColumns.removeElement(region);
+ hiddenColumns.remove(region);
break;
}
}
* @param intervals
* @return
*/
- private boolean pruneIntervalVector(final List<int[]> shifts,
- Vector<int[]> intervals)
+ private boolean pruneIntervalList(final List<int[]> shifts,
+ ArrayList<int[]> 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);
+ int[] hr = intervals.get(i);
+ int[] sr = shifts.get(s);
while (i <= j && s <= t)
{
boolean trailinghn = hr[1] >= sr[0];
{
if (i < j)
{
- hr = intervals.elementAt(++i);
+ hr = intervals.get(++i);
}
else
{
{
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;
}
// delete any intervals intersecting.
if (hiddenColumns != null)
{
- pruneIntervalVector(shifts, hiddenColumns);
+ pruneIntervalList(shifts, hiddenColumns);
if (hiddenColumns != null && hiddenColumns.size() == 0)
{
hiddenColumns = null;
.nextSetBit(lastSet))
{
lastSet = inserts.nextClearBit(firstSet);
- hideColumns(firstSet, lastSet - 1, true);
+ hideColumns(firstSet, lastSet - 1);
}
} finally
{
git://source.jalview.org / jalview.git / blobdiff