public class IntervalStore0<T extends IntervalI>
extends AbstractCollection<T> implements IntervalStoreI<T>
{
+ private static int NOT_CONTAINED = Integer.MIN_VALUE;
/**
* Search for the last interval that starts before or at the specified from/to
}
DO_PRESORT = presort;
icompare = (comparator != null ? comparator
- : bigendian ? IntervalI.COMPARATOR_BIGENDIAN
- : IntervalI.COMPARATOR_LITTLEENDIAN);
+ : bigendian ? IntervalI.COMPARE_BEGIN_ASC_END_DESC
+ : IntervalI.COMPARE_BEGIN_ASC_END_ASC);
this.bigendian = bigendian;
if (DO_PRESORT && intervalCount > 1)
@Override
public boolean add(T interval)
{
- return add(interval, true);
+ return add(interval, false);
}
/**
int pt0 = pt;
while (--pt >= 0 && offsets[pt] == 0)
{
- ;
+
}
if (pt < 0)
{
case 0:
IntervalI iv = intervals[mid];
if ((bsIgnore == null || !bsIgnore.get(mid))
- && iv.equalsInterval(interval))
+ && sameInterval(interval, iv))
{
return mid;
// found one; just scan up and down now, first checking the range, but
break;
}
if ((bsIgnore == null || !bsIgnore.get(i))
- && iv.equalsInterval(interval))
+ && sameInterval(interval, iv))
{
return i;
}
return -1 - ++i;
}
if ((bsIgnore == null || !bsIgnore.get(i))
- && iv.equalsInterval(interval))
+ && sameInterval(interval, iv))
{
return i;
}
return -1 - start;
}
- // private int binaryInsertionSearch(long from, long to)
- // {
- // int matched = intervalCount;
- // int end = matched - 1;
- // int start = matched;
- // if (end < 0 || from > intervals[end].getEnd()
- // || from < intervals[start = 0].getBegin())
- // return start;
- // while (start <= end)
- // {
- // int mid = (start + end) >>> 1;
- // switch (compareRange(intervals[mid], from, to))
- // {
- // case 0:
- // return mid;
- // case 1:
- // matched = mid;
- // end = mid - 1;
- // continue;
- // case -1:
- // start = mid + 1;
- // continue;
- // }
- //
- // }
- // return matched;
- // }
+ boolean sameInterval(IntervalI i1, IntervalI i2)
+ {
+ /*
+ * do the quick test of begin/end first for speed
+ */
+ return i1.equalsInterval(i2) && i1.equals(i2);
+ }
@Override
public void clear()
return result;
}
- @Override
- public IntervalI get(int i)
- {
- if (i < 0 || i >= intervalCount + added)
- {
- return null;
- }
- ensureFinalized();
- return intervals[i];
- }
-
private int getContainedBy(int index, int begin)
{
while (index >= 0)
}
index -= Math.abs(offsets[index]);
}
- return IntervalI.NOT_CONTAINED;
+ return NOT_CONTAINED;
}
@Override
for (int i = 0; i < intervalCount; i++)
{
IntervalI element = intervals[i];
- if (offsets[i] == IntervalI.NOT_CONTAINED)
+ if (offsets[i] == NOT_CONTAINED)
{
root = element;
}
return maxDepth;
}
- @Override
- public int getWidth()
- {
- ensureFinalized();
- int w = 0;
- for (int i = offsets.length; --i >= 0;)
- {
- if (offsets[i] > 0)
- {
- w++;
- }
- }
- return w;
- }
-
- @Override
- public boolean isValid()
- {
- ensureFinalized();
- return true;
- }
-
/**
* Answers an iterator over the intervals in the store, with no particular
* ordering guaranteed. The iterator does not support the optional
return;
}
maxEnd = intervals[0].getEnd();
- offsets[0] = IntervalI.NOT_CONTAINED;
+ offsets[0] = NOT_CONTAINED;
if (intervalCount == 1)
{
return;
// System.out.println(sf + " is contained by "
// + (index < 0 ? null : starts[index]));
- offsets[i] = (index < 0 ? IntervalI.NOT_CONTAINED
+ offsets[i] = (index < 0 ? NOT_CONTAINED
: isMonotonic ? index - i : i - index);
isMonotonic = (sf.getEnd() > maxEnd);
if (isMonotonic)
case -1:
break;
case 0:
- if (iv.equalsInterval(interval))
+ if (sameInterval(interval, iv))
{
return pt;
}
else
{
int i = intervalCount;
- while (--i >= 0 && !intervals[i].equalsInterval(interval))
+ while (--i >= 0 && !sameInterval(intervals[i], interval))
{
- ;
+
}
return i;
}
}
@Override
- public boolean revalidate()
- {
- isTainted = true;
- isSorted = false;
- ensureFinalized();
- return true;
- }
-
- @Override
public int size()
{
return intervalCount + added - deleted;
{
return prettyPrint();
}
-
- @Override
- public boolean canCheckForDuplicates()
- {
- return true;
- }
-
}