consumer) {
- this.threadSafe = threadSafe;
- this.bitSetSize = size;
- this.consumer = consumer;
- }
-
- /**
- * Adds the specified range to this {@code RangeSet} (optional operation). That is, for equal range sets a and b,
- * the result of {@code a.add(range)} is that {@code a} will be the minimal range set for which both
- * {@code a.enclosesAll(b)} and {@code a.encloses(range)}.
- *
- * Note that {@code range} will merge given {@code range} with any ranges in the range set that are
- * {@linkplain Range#isConnected(Range) connected} with it. Moreover, if {@code range} is empty, this is a no-op.
- */
- @Override
- public void addOpenClosed(long lowerKey, long lowerValueOpen, long upperKey, long upperValue) {
- long lowerValue = lowerValueOpen + 1;
- if (lowerKey != upperKey) {
- // (1) set lower to last in lowerRange.getKey()
- if (isValid(lowerKey, lowerValue)) {
- BitSet rangeBitSet = rangeBitSetMap.get(lowerKey);
- // if lower and upper has different key/ledger then set ranges for lower-key only if
- // a. bitSet already exist and given value is not the last value in the bitset.
- // it will prevent setting up values which are not actually expected to set
- // eg: (2:10..4:10] in this case, don't set any value for 2:10 and set [4:0..4:10]
- if (rangeBitSet != null && (rangeBitSet.previousSetBit(rangeBitSet.size()) > lowerValueOpen)) {
- int lastValue = rangeBitSet.previousSetBit(rangeBitSet.size());
- rangeBitSet.set((int) lowerValue, (int) Math.max(lastValue, lowerValue) + 1);
- }
- }
- // (2) set 0th-index to upper-index in upperRange.getKey()
- if (isValid(upperKey, upperValue)) {
- BitSet rangeBitSet = rangeBitSetMap.computeIfAbsent(upperKey, (key) -> createNewBitSet());
- if (rangeBitSet != null) {
- rangeBitSet.set(0, (int) upperValue + 1);
- }
- }
- // No-op if values are not valid eg: if lower == LongPair.earliest or upper == LongPair.latest then nothing
- // to set
- } else {
- long key = lowerKey;
- BitSet rangeBitSet = rangeBitSetMap.computeIfAbsent(key, (k) -> createNewBitSet());
- rangeBitSet.set((int) lowerValue, (int) upperValue + 1);
- }
- updatedAfterCachedForSize = true;
- updatedAfterCachedForToString = true;
- }
-
- private boolean isValid(long key, long value) {
- return key != LongPair.earliest.getKey() && value != LongPair.earliest.getValue()
- && key != LongPair.latest.getKey() && value != LongPair.latest.getValue();
- }
-
- @Override
- public boolean contains(long key, long value) {
-
- BitSet rangeBitSet = rangeBitSetMap.get(key);
- if (rangeBitSet != null) {
- return rangeBitSet.get(getSafeEntry(value));
- }
- return false;
- }
-
- @Override
- public Range rangeContaining(long key, long value) {
- BitSet rangeBitSet = rangeBitSetMap.get(key);
- if (rangeBitSet != null) {
- if (!rangeBitSet.get(getSafeEntry(value))) {
- // if position is not part of any range then return null
- return null;
- }
- int lowerValue = rangeBitSet.previousClearBit(getSafeEntry(value)) + 1;
- final T lower = consumer.apply(key, lowerValue);
- final T upper = consumer.apply(key,
- Math.max(rangeBitSet.nextClearBit(getSafeEntry(value)) - 1, lowerValue));
- return Range.closed(lower, upper);
- }
- return null;
- }
-
- @Override
- public void removeAtMost(long key, long value) {
- this.remove(Range.atMost(new LongPair(key, value)));
- }
-
- @Override
- public boolean isEmpty() {
- if (rangeBitSetMap.isEmpty()) {
- return true;
- }
- for (BitSet rangeBitSet : rangeBitSetMap.values()) {
- if (!rangeBitSet.isEmpty()) {
- return false;
- }
- }
- return true;
- }
-
- @Override
- public void clear() {
- rangeBitSetMap.clear();
- updatedAfterCachedForSize = true;
- updatedAfterCachedForToString = true;
- }
-
- @Override
- public Range span() {
- if (rangeBitSetMap.isEmpty()) {
- return null;
- }
- Entry firstSet = rangeBitSetMap.firstEntry();
- Entry lastSet = rangeBitSetMap.lastEntry();
- int first = firstSet.getValue().nextSetBit(0);
- int last = lastSet.getValue().previousSetBit(lastSet.getValue().size());
- return Range.openClosed(consumer.apply(firstSet.getKey(), first - 1), consumer.apply(lastSet.getKey(), last));
- }
-
- @Override
- public List> asRanges() {
- List> ranges = new ArrayList<>();
- forEach((range) -> {
- ranges.add(range);
- return true;
- });
- return ranges;
- }
-
- @Override
- public void forEach(RangeProcessor action) {
- forEach(action, consumer);
- }
-
- @Override
- public void forEach(RangeProcessor action, LongPairConsumer consumerParam) {
- forEachRawRange((lowerKey, lowerValue, upperKey, upperValue) -> {
- Range range = Range.openClosed(
- consumerParam.apply(lowerKey, lowerValue),
- consumerParam.apply(upperKey, upperValue)
- );
- return action.process(range);
- });
- }
-
- @Override
- public void forEachRawRange(RawRangeProcessor processor) {
- AtomicBoolean completed = new AtomicBoolean(false);
- rangeBitSetMap.forEach((key, set) -> {
- if (completed.get()) {
- return;
- }
- if (set.isEmpty()) {
- return;
- }
- int first = set.nextSetBit(0);
- int last = set.previousSetBit(set.size());
- int currentClosedMark = first;
- while (currentClosedMark != -1 && currentClosedMark <= last) {
- int nextOpenMark = set.nextClearBit(currentClosedMark);
- if (!processor.processRawRange(key, currentClosedMark - 1,
- key, nextOpenMark - 1)) {
- completed.set(true);
- break;
- }
- currentClosedMark = set.nextSetBit(nextOpenMark);
- }
- });
- }
-
-
- @Override
- public Range firstRange() {
- if (rangeBitSetMap.isEmpty()) {
- return null;
- }
- Entry firstSet = rangeBitSetMap.firstEntry();
- int lower = firstSet.getValue().nextSetBit(0);
- int upper = Math.max(lower, firstSet.getValue().nextClearBit(lower) - 1);
- return Range.openClosed(consumer.apply(firstSet.getKey(), lower - 1), consumer.apply(firstSet.getKey(), upper));
- }
-
- @Override
- public Range lastRange() {
- if (rangeBitSetMap.isEmpty()) {
- return null;
- }
- Entry lastSet = rangeBitSetMap.lastEntry();
- int upper = lastSet.getValue().previousSetBit(lastSet.getValue().size());
- int lower = Math.min(lastSet.getValue().previousClearBit(upper), upper);
- return Range.openClosed(consumer.apply(lastSet.getKey(), lower), consumer.apply(lastSet.getKey(), upper));
- }
-
- @Override
- public int cardinality(long lowerKey, long lowerValue, long upperKey, long upperValue) {
- NavigableMap subMap = rangeBitSetMap.subMap(lowerKey, true, upperKey, true);
- MutableInt v = new MutableInt(0);
- subMap.forEach((key, bitset) -> {
- if (key == lowerKey || key == upperKey) {
- BitSet temp = (BitSet) bitset.clone();
- // Trim the bitset index which < lowerValue
- if (key == lowerKey) {
- temp.clear(0, (int) Math.max(0, lowerValue));
- }
- // Trim the bitset index which > upperValue
- if (key == upperKey) {
- temp.clear((int) Math.min(upperValue + 1, temp.length()), temp.length());
- }
- v.add(temp.cardinality());
- } else {
- v.add(bitset.cardinality());
- }
- });
- return v.intValue();
- }
-
- @Override
- public int size() {
- if (updatedAfterCachedForSize) {
- MutableInt size = new MutableInt(0);
-
- // ignore result because we just want to count
- forEachRawRange((lowerKey, lowerValue, upperKey, upperValue) -> {
- size.increment();
- return true;
- });
-
- cachedSize = size.intValue();
- updatedAfterCachedForSize = false;
- }
- return cachedSize;
- }
-
- @Override
- public String toString() {
- if (updatedAfterCachedForToString) {
- StringBuilder toString = new StringBuilder();
- AtomicBoolean first = new AtomicBoolean(true);
- if (toString != null) {
- toString.append("[");
- }
- forEach((range) -> {
- if (!first.get()) {
- toString.append(",");
- }
- toString.append(range);
- first.set(false);
- return true;
- });
- toString.append("]");
- cachedToString = toString.toString();
- updatedAfterCachedForToString = false;
- }
- return cachedToString;
- }
-
- /**
- * Adds the specified range to this {@code RangeSet} (optional operation). That is, for equal range sets a and b,
- * the result of {@code a.add(range)} is that {@code a} will be the minimal range set for which both
- * {@code a.enclosesAll(b)} and {@code a.encloses(range)}.
- *
- * Note that {@code range} will merge given {@code range} with any ranges in the range set that are
- * {@linkplain Range#isConnected(Range) connected} with it. Moreover, if {@code range} is empty/invalid, this is a
- * no-op.
- */
- public void add(Range range) {
- LongPair lowerEndpoint = range.hasLowerBound() ? range.lowerEndpoint() : LongPair.earliest;
- LongPair upperEndpoint = range.hasUpperBound() ? range.upperEndpoint() : LongPair.latest;
-
- long lowerValueOpen = (range.hasLowerBound() && range.lowerBoundType().equals(BoundType.CLOSED))
- ? getSafeEntry(lowerEndpoint) - 1
- : getSafeEntry(lowerEndpoint);
- long upperValueClosed = (range.hasUpperBound() && range.upperBoundType().equals(BoundType.CLOSED))
- ? getSafeEntry(upperEndpoint)
- : getSafeEntry(upperEndpoint) + 1;
-
- // #addOpenClosed doesn't create bitSet for lower-key because it avoids setting up values for non-exist items
- // into the key-ledger. so, create bitSet and initialize so, it can't be ignored at #addOpenClosed
- rangeBitSetMap.computeIfAbsent(lowerEndpoint.getKey(), (key) -> createNewBitSet())
- .set((int) lowerValueOpen + 1);
- this.addOpenClosed(lowerEndpoint.getKey(), lowerValueOpen, upperEndpoint.getKey(), upperValueClosed);
- }
-
- public boolean contains(LongPair position) {
- requireNonNull(position, "argument can't be null");
- return contains(position.getKey(), position.getValue());
- }
-
- public void remove(Range range) {
- LongPair lowerEndpoint = range.hasLowerBound() ? range.lowerEndpoint() : LongPair.earliest;
- LongPair upperEndpoint = range.hasUpperBound() ? range.upperEndpoint() : LongPair.latest;
-
- long lower = (range.hasLowerBound() && range.lowerBoundType().equals(BoundType.CLOSED))
- ? getSafeEntry(lowerEndpoint)
- : getSafeEntry(lowerEndpoint) + 1;
- long upper = (range.hasUpperBound() && range.upperBoundType().equals(BoundType.CLOSED))
- ? getSafeEntry(upperEndpoint)
- : getSafeEntry(upperEndpoint) - 1;
-
- // if lower-bound is not set then remove all the keys less than given upper-bound range
- if (lowerEndpoint.equals(LongPair.earliest)) {
- // remove all keys with
- rangeBitSetMap.forEach((key, set) -> {
- if (key < upperEndpoint.getKey()) {
- rangeBitSetMap.remove(key);
- }
- });
- }
-
- // if upper-bound is not set then remove all the keys greater than given lower-bound range
- if (upperEndpoint.equals(LongPair.latest)) {
- // remove all keys with
- rangeBitSetMap.forEach((key, set) -> {
- if (key > lowerEndpoint.getKey()) {
- rangeBitSetMap.remove(key);
- }
- });
- }
-
- // remove all the keys between two endpoint keys
- rangeBitSetMap.forEach((key, set) -> {
- if (lowerEndpoint.getKey() == upperEndpoint.getKey() && key == upperEndpoint.getKey()) {
- set.clear((int) lower, (int) upper + 1);
- } else {
- // eg: remove-range: [(3,5) - (5,5)] -> Delete all items from 3,6->3,N,4.*,5,0->5,5
- if (key == lowerEndpoint.getKey()) {
- // remove all entries from given position to last position
- set.clear((int) lower, set.previousSetBit(set.size()));
- } else if (key == upperEndpoint.getKey()) {
- // remove all entries from 0 to given position
- set.clear(0, (int) upper + 1);
- } else if (key > lowerEndpoint.getKey() && key < upperEndpoint.getKey()) {
- rangeBitSetMap.remove(key);
- }
- }
- // remove bit-set if set is empty
- if (set.isEmpty()) {
- rangeBitSetMap.remove(key);
- }
- });
-
- updatedAfterCachedForSize = true;
- updatedAfterCachedForToString = true;
- }
-
- private int getSafeEntry(LongPair position) {
- return (int) Math.max(position.getValue(), -1);
- }
-
- private int getSafeEntry(long value) {
- return (int) Math.max(value, -1);
- }
-
- private BitSet createNewBitSet() {
- return this.threadSafe ? new ConcurrentBitSet(bitSetSize) : new BitSet(bitSetSize);
- }
-
-}
\ No newline at end of file