private HiddenColumnsCursor cursor = new HiddenColumnsCursor();
/*
- * cache of the number of hidden columns
+ * cache of the number of hidden columns: must be kept up to date by methods
+ * which add or remove hidden columns
*/
private int numColumns = 0;
*/
private List<int[]> hiddenColumns = new ArrayList<>();
+ private BitSet hiddenBitSet;
+
+ /**
+ * Returns a BitSet with a set bit for each hidden column (0, 1, ...). This is
+ * valid at the time of calling, but will not reflect any changes made
+ * afterwards.
+ *
+ * @return
+ */
+ public BitSet getBitset()
+ {
+ if (hiddenBitSet == null)
+ {
+ hiddenBitSet = new BitSet();
+ for (int[] range : hiddenColumns)
+ {
+ hiddenBitSet.set(range[0], range[1] + 1);
+ }
+ }
+ return hiddenBitSet;
+ }
/**
* Constructor
*/
prevHiddenCount);
} finally
{
+ hiddenBitSet = null;
LOCK.writeLock().unlock();
}
}
insertRangeAtOverlap(i, start, end, region);
added = true;
}
+ hiddenBitSet = null;
return added;
}
}
numColumns += region[1] - oldend;
hiddenColumns.subList(i + 1, endi + 1).clear();
+ hiddenBitSet = null;
}
/**
} finally
{
+ hiddenBitSet = null;
LOCK.writeLock().unlock();
}
}
} finally
{
+ hiddenBitSet = null;
LOCK.writeLock().unlock();
}
}
int colsToRemove = region[1] - region[0] + 1;
hiddenColumns.remove(regionIndex);
numColumns -= colsToRemove;
-
- cursor.updateForDeletedRegion(hiddenColumns);
}
}
}
} finally
{
+ hiddenBitSet = null;
LOCK.writeLock().unlock();
}
}
}
}
+ /**
+ * Answers true if obj is an instance of HiddenColumns, and holds the same
+ * array of start-end column ranges as this, else answers false
+ */
@Override
public boolean equals(Object obj)
{
} finally
{
+ hiddenBitSet = null;
LOCK.readLock().unlock();
}
}
{
LOCK.readLock().lock();
- int regionindex = cursor.findRegionForColumn(column, false)
- .getRegionIndex();
- if (regionindex > -1 && regionindex < hiddenColumns.size())
+ if (!hiddenColumns.isEmpty())
{
- int[] region = hiddenColumns.get(regionindex);
- // already know that column <= region[1] as cursor returns containing
- // region or region to right
- if (column >= region[0])
+ int regionindex = cursor.findRegionForColumn(column, false)
+ .getRegionIndex();
+ if (regionindex > -1 && regionindex < hiddenColumns.size())
{
- return false;
+ int[] region = hiddenColumns.get(regionindex);
+ // already know that column <= region[1] as cursor returns containing
+ // region or region to right
+ if (column >= region[0])
+ {
+ return false;
+ }
}
}
return true;
*/
public void hideColumns(BitSet inserts)
{
+ hideColumns(inserts, 0, inserts.length() - 1);
+ }
+
+ /**
+ * Hide columns corresponding to the marked bits, within the range
+ * [start,end]. Entries in tohide which are outside [start,end] are ignored.
+ *
+ * @param tohide
+ * columns mapped to bits starting from zero
+ * @param start
+ * start of range to hide columns within
+ * @param end
+ * end of range to hide columns within
+ */
+ private void hideColumns(BitSet tohide, int start, int end)
+ {
try
{
LOCK.writeLock().lock();
- for (int firstSet = inserts
- .nextSetBit(0), lastSet = 0; firstSet >= 0; firstSet = inserts
- .nextSetBit(lastSet))
+ for (int firstSet = tohide
+ .nextSetBit(start), lastSet = start; firstSet >= start
+ && lastSet <= end; firstSet = tohide
+ .nextSetBit(lastSet))
{
- lastSet = inserts.nextClearBit(firstSet);
- hideColumns(firstSet, lastSet - 1);
+ lastSet = tohide.nextClearBit(firstSet);
+ if (lastSet <= end)
+ {
+ hideColumns(firstSet, lastSet - 1);
+ }
+ else if (firstSet <= end)
+ {
+ hideColumns(firstSet, end);
+ }
}
cursor = new HiddenColumnsCursor(hiddenColumns);
} finally
{
+ hiddenBitSet = null;
LOCK.writeLock().unlock();
}
}
/**
* Hide columns corresponding to the marked bits, within the range
* [start,end]. Entries in tohide which are outside [start,end] are ignored.
+ * NB Existing entries in [start,end] are cleared.
*
* @param tohide
* columns mapped to bits starting from zero
* @param end
* end of range to hide columns within
*/
- public void hideColumns(BitSet tohide, int start, int end)
+ public void clearAndHideColumns(BitSet tohide, int start, int end)
{
clearHiddenColumnsInRange(start, end);
-
- // make sure only bits between start and end are set
- if (!tohide.isEmpty())
- {
- tohide.clear(0, start);
- tohide.clear(Math.min(end + 1, tohide.length() + 1),
- tohide.length() + 1);
- }
-
- hideColumns(tohide);
+ hideColumns(tohide, start, end);
}
/**
}
} finally
{
+ hiddenBitSet = null;
LOCK.writeLock().unlock();
}
}
{
LOCK.writeLock().lock();
- BitSet hiddenBitSet = new BitSet();
- for (int[] range : hiddenColumns)
- {
- hiddenBitSet.set(range[0], range[1] + 1);
- }
- hiddenBitSet.andNot(updates);
+ getBitset().andNot(updates);
hiddenColumns.clear();
hideColumns(hiddenBitSet);
} finally
{
+ hiddenBitSet = null;
LOCK.writeLock().unlock();
}
}
try
{
LOCK.readLock().lock();
- return new HiddenColsIterator(hiddenColumns);
+ return new RangeIterator(hiddenColumns);
} finally
{
LOCK.readLock().unlock();
try
{
LOCK.readLock().lock();
- return new HiddenColsIterator(start, end, hiddenColumns);
+ return new RangeIterator(start, end, hiddenColumns);
} finally
{
LOCK.readLock().unlock();
* @param end
* position to end at (inclusive, visible column position)
*/
- public Iterator<Integer> getBoundedStartIterator(int start, int end)
+ public Iterator<Integer> getStartRegionIterator(int start, int end)
{
try
{
HiddenCursorPosition pos = cursor
.findRegionForColumn(absoluteStart - 1, false);
- return new BoundedStartRegionIterator(pos, start, end,
+ return new StartRegionIterator(pos, start, end,
hiddenColumns);
} finally
{
try
{
LOCK.readLock().lock();
- return new VisibleColsIterator(start, end, hiddenColumns);
+ return new RangeElementsIterator(
+ new VisibleContigsIterator(start, end + 1, hiddenColumns));
} finally
{
LOCK.readLock().unlock();
git://source.jalview.org / jalview.git / blobdiff