/*
* Copyright 2018 faddenSoft
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
namespace CommonUtil {
///
/// Compact representation of a set of integers that tend to be adjacent.
///
/// The default enumeration is a series of integers, not a series of ranges. Use
/// RangeListIterator to get the latter.
///
/// Most operations operate in log(N) time, where N is the number of
/// regions.
///
public class RangeSet : IEnumerable {
///
/// List of ranges, in sorted order.
///
private List mRangeList = new List();
///
/// Number of values in the set.
///
public int Count { get; private set; }
///
/// For unit tests: return the number of Range elements in the list.
///
public int DebugRangeCount { get { return mRangeList.Count; } }
///
/// Represents a contiguous range of values.
///
public struct Range {
///
/// Lowest value (inclusive).
///
public int Low { get; set; }
///
/// Highest value (inclusive).
///
public int High { get; set; }
public Range(int low, int high) {
Debug.Assert(low <= high);
Low = low;
High = high;
}
///
/// Returns true if the specified value falls in this range.
///
public bool Contains(int val) {
return (val >= Low && val <= High);
}
}
///
/// Iterator definition.
///
private class RangeSetIterator : IEnumerator {
///
/// The RangeSet we're iterating over.
///
private RangeSet mSet;
// Index of current Range element in mSet.mRangeList.
private int mListIndex = -1;
// Current range, extracted from mRangeList.
private Range mCurrentRange;
// Current value in mCurrentRange.
private int mCurrentVal;
///
/// Constructor.
///
/// RangeSet to iterate over.
public RangeSetIterator(RangeSet set) {
mSet = set;
Reset();
}
// IEnumerator: current element
public object Current {
get {
if (mListIndex < 0) {
// not started
return null;
}
return mCurrentVal;
}
}
///
/// Puts the next range in the list in mCurrentRange.
///
/// True on success, false if we reached the end of the list.
private bool GetNextRange() {
mListIndex++; // increments to 0 on first invocation
if (mListIndex == mSet.mRangeList.Count) {
// no more ranges
return false;
}
mCurrentRange = mSet.mRangeList[mListIndex];
mCurrentVal = mCurrentRange.Low;
return true;
}
// IEnumerator: move to the next element, returning false if there isn't one
public bool MoveNext() {
if (mListIndex < 0) {
// just started
return GetNextRange();
} else {
// iterating within range object
mCurrentVal++;
if (mCurrentVal > mCurrentRange.High) {
// finished with this one, move on to the next
return GetNextRange();
} else {
return true;
}
}
}
// IEnumerator: reset state
public void Reset() {
mListIndex = -1;
}
}
///
/// General constructor. Creates an empty set.
///
public RangeSet() {
Count = 0;
}
///
/// Constructs set from an iterator.
///
/// Iterator that generates a set of integers in ascending order.
public RangeSet(IEnumerator iter) : this() {
if (!iter.MoveNext()) {
return;
}
int first = (int) iter.Current;
Count++;
Range curRange = new Range(first, first);
while (iter.MoveNext()) {
int val = (int) iter.Current;
Count++;
if (val == curRange.High + 1) {
// Add to current range.
curRange.High = val;
} else {
// Not contiguous, create new range.
mRangeList.Add(curRange);
curRange = new Range(val, val);
}
}
mRangeList.Add(curRange);
}
///
/// Returns an enumerator that iterates through the range list, returning Range objects.
///
public IEnumerator RangeListIterator {
get { return mRangeList.GetEnumerator(); }
}
///
/// Removes all values from the set.
///
public void Clear() {
mRangeList.Clear();
Count = 0;
}
// IEnumerable: get an enumerator instance that returns integer values
public IEnumerator GetEnumerator() {
return new RangeSetIterator(this);
}
// IEnumerable
IEnumerator IEnumerable.GetEnumerator() {
return (IEnumerator)GetEnumerator();
}
///
/// Finds the range that contains "val", or an appropriate place in the list to
/// insert a new range.
///
/// Value to find.
/// The index of the matching element, or a negative value indicating
/// the index to insert at. 2C doesn't support negative 0, so the insertion
/// index will be incremented before negation.
private int FindValue(int val) {
int low = 0;
int high = mRangeList.Count - 1;
while (low <= high) {
int mid = (low + high) / 2;
Range midRange = mRangeList[mid];
if (midRange.Contains(val)) {
// found it
return mid;
} else if (val < midRange.Low) {
// too big, move the high end in
high = mid - 1;
} else if (val > midRange.High) {
// too small, move the low end in
low = mid + 1;
} else {
// WTF... list not sorted?
throw new Exception("Bad binary search");
}
}
// Not found, insert before "low".
return -(low + 1);
}
///
/// Determines whether val is a member of the set.
///
/// Value to check.
/// True if the value is a member of the set.
public bool Contains(int val) {
return (FindValue(val) >= 0);
}
#if false
///
/// Finds a range that contains searchVal, or identifies the one that immediately
/// follows. The caller can determine which by checking to see if range.Low is
/// greater than searchVal.
///
/// Value to find.
/// Result.
/// True if a valid range was returned.
public bool GetContainingOrSubsequentRange(int searchVal, out Range range) {
int index = FindValue(searchVal);
if (index >= 0) {
// found a range that contains val
range = mRangeList[index];
return true;
}
// No matching range, so the index of the insertion point was returned. The
// indexed range will have a "low" value that is greater than searchVal. If
// we've reached the end of the list, the index will be past the end.
index = -index - 1;
if (index >= mRangeList.Count) {
// reached the end of the list
range = new Range(-128, -128);
return false;
}
range = mRangeList[index];
return true;
}
#endif
///
/// Adds a value to the set. If the value is already present, nothing changes.
///
/// Value to add.
public void Add(int val) {
int listIndex = FindValue(val);
if (listIndex >= 0) {
// Already present in set.
return;
}
Count++;
if (mRangeList.Count == 0) {
// Empty list, skip the gymnastics.
mRangeList.Add(new Range(val, val));
return;
}
// Negate and decrement to get insertion index. This value may == Count if
// the value is higher than all current members.
listIndex = -listIndex - 1;
if (listIndex > 0 && mRangeList[listIndex - 1].High == val - 1) {
// Expand prior range. Check to see if it blends into next.
if (listIndex < mRangeList.Count && mRangeList[listIndex].Low == val + 1) {
// Combine ranges.
Range prior = mRangeList[listIndex - 1];
Range next = mRangeList[listIndex];
Debug.Assert(prior.High + 2 == next.Low);
prior.High = next.High;
mRangeList[listIndex - 1] = prior;
mRangeList.RemoveAt(listIndex);
} else {
// Nope, just expand the prior range.
Range prior = mRangeList[listIndex - 1];
Debug.Assert(prior.High == val - 1);
prior.High = val;
mRangeList[listIndex - 1] = prior;
}
} else if (listIndex < mRangeList.Count && mRangeList[listIndex].Low == val + 1) {
// Expand next range.
Range next = mRangeList[listIndex];
Debug.Assert(next.Low == val + 1);
next.Low = val;
mRangeList[listIndex] = next;
} else {
// Add a new single-entry element.
mRangeList.Insert(listIndex, new Range(val, val));
}
}
///
/// Adds a range of contiguous values to the set.
///
/// Lowest value (inclusive).
/// Highest value (inclusive).
public void AddRange(int low, int high) {
// There's probably some very efficient way to do this. Keeping it simple for now.
for (int i = low; i <= high; i++) {
Add(i);
}
}
///
/// Removes a value from the set. If the value is not present, nothing changes.
///
/// Value to remove.
public void Remove(int val) {
int listIndex = FindValue(val);
if (listIndex < 0) {
// not found
return;
}
Count--;
Range rng = mRangeList[listIndex];
if (rng.Low == val && rng.High == val) {
// Single-value range. Remove.
mRangeList.RemoveAt(listIndex);
} else if (rng.Low == val) {
// We're at the low end, reduce range.
rng.Low = val + 1;
mRangeList[listIndex] = rng;
} else if (rng.High == val) {
// We're at the high end, reduce range.
rng.High = val - 1;
mRangeList[listIndex] = rng;
} else {
// We're in the middle, split the range.
Range next = new Range(val + 1, rng.High);
rng.High = val - 1;
mRangeList[listIndex] = rng;
mRangeList.Insert(listIndex + 1, next);
}
}
public void DebugDump(string name) {
Debug.WriteLine(name + " has " + DebugRangeCount + " ranges");
IEnumerator iter = RangeListIterator;
while (iter.MoveNext()) {
Range rng = iter.Current;
Debug.WriteLine("[+{0:x6},+{1:x6}]", rng.Low, rng.High);
}
}
///
/// Internal test helper function.
///
private static bool CheckRangeSet(RangeSet set, int expectedRanges, int[] expected) {
if (set.DebugRangeCount != expectedRanges) {
Debug.WriteLine("Expected " + expectedRanges + " ranges, got " +
set.DebugRangeCount);
return false;
}
// Compare actual vs. expected. If we have more actual than expected we'll
// throw on the array access.
int expIndex = 0;
foreach (int val in set) {
if (val != expected[expIndex]) {
Debug.WriteLine("Expected " + expected[expIndex] + ", got " + val);
return false;
}
expIndex++;
}
// See if we have more expected than actual.
if (expIndex != expected.Length) {
Debug.WriteLine("Expected " + expected.Length + " elements, found " + expIndex);
return false;
}
// The count is maintained separately, so check it.
if (set.Count != expected.Length) {
Debug.WriteLine("Expected Count=" + expected.Length + ", got " + set.Count);
return false;
}
return true;
}
///
/// Executes unit tests.
///
/// True if all goes well.
public static bool Test() {
bool result = true;
RangeSet one = new RangeSet();
one.Add(7);
one.Add(5);
one.Add(3);
one.Add(9);
one.Add(7);
one.Add(8);
one.Add(2);
one.Add(4);
result &= CheckRangeSet(one, 2, new int[] { 2, 3, 4, 5, 7, 8, 9 });
one.Remove(2);
one.Remove(9);
one.Remove(4);
result &= CheckRangeSet(one, 3, new int[] { 3, 5, 7, 8 });
one.Clear();
one.AddRange(10, 15);
result &= CheckRangeSet(one, 1, new int[] { 10, 11, 12, 13, 14, 15 });
one.Add(-1);
one.Add(0);
one.Add(-2);
result &= CheckRangeSet(one, 2, new int[] { -2, -1, 0, 10, 11, 12, 13, 14, 15 });
Debug.WriteLine("RangeSet: test complete (ok=" + result + ")");
return result;
}
}
}