public static ISortedEnumerable <TResult> SelectSorted <TSource, TResult>(this ISortedEnumerable <TSource> sequence, Func <TSource, TResult> selector, Func <TResult, TResult, int> resultComparer = null)
{
Contract.Requires <ArgumentNullException>(sequence != null);
Contract.Requires <ArgumentNullException>(selector != null);
return(new SortedEnumerable <TResult>(((IEnumerable <TSource>)sequence).Select(selector), resultComparer));
}
public static void EnsureSingleEnumerationDEBUGSorted <T>(ref ISortedEnumerable <T> sequence)
{
if (sequence != null)
{
sequence = new SortedList <T>(sequence.ToList(), sequence.Comparer);
}
}
/// <summary>
/// Filters the specified sorted sequence on the specified predicate.
/// </summary>
public static ISortedEnumerable <TSource> WhereSorted <TSource>(this ISortedEnumerable <TSource> sequence, Func <TSource, bool> predicate)
{
Contract.Requires(sequence != null);
Contract.Requires(predicate != null);
return(new SortedEnumerable <TSource>(sequence.Where(predicate), sequence.Comparer));
}
/// <summary> Yields all elements that are between the elements in the specified sorted sequence. So basically, this is exclusion of the sequence from the range of the sequence. </summary>
/// <typeparam name="T"> The type of the elements. </typeparam>
/// <param name="sequence"> The sequence of the elements that are not yielded. </param>
/// <param name="increment"> A function specifying the next element given one. </param>
/// <param name="start"> The start of the range of all elements to yield. </param>
/// <param name="end"> The end of the range of all elements to yield. </param>
/// <param name="equalityComparer"> The equality comparer used for determining whether an element in the specified sequence matches that in the range. </param>
public static IEnumerable <T> RangeExcept <T>(this ISortedEnumerable <T> sequence, Func <T, T> increment, T start, T end, IEqualityComparer <T> equalityComparer = null)
{
Contract.Requires(sequence != null);
Contract.Requires(increment != null);
Contract.Requires(sequence.IsSorted(sequence.Comparer));
equalityComparer = equalityComparer ?? EqualityComparer <T> .Default;
T previouslyExcludedElement = start;
bool first = true;
foreach (var excludedElement in sequence.Concat(end))
{
foreach (var elementBelowExcludedElement in Range(previouslyExcludedElement, increment, excludedElement, equalityComparer, first))
{
if (equalityComparer.Equals(end, elementBelowExcludedElement))
{
yield break;
}
yield return(elementBelowExcludedElement);
}
if (equalityComparer.Equals(end, excludedElement))
{
yield break;
}
previouslyExcludedElement = excludedElement;
first = false;
}
}
public void SortedEnumerable_RepeatWithDelegate_EnumeratesRepeatedItem()
{
int source = 13;
ISortedEnumerable <int> result = SortedEnumerableSource.Repeat(source, (x, y) => Comparer <int> .Default.Compare(y, x), 3);
Assert.IsTrue(result.SequenceEqual(new[] { 13, 13, 13 }), "Item should be repeated.");
}
public void SortedEnumerable_Repeat_EnumeratesRepeatedItem()
{
int source = 13;
ISortedEnumerable <int> result = SortedEnumerableSource.Repeat(source, 3);
Assert.IsTrue(result.SequenceEqual(new[] { 13, 13, 13 }), "Item should be repeated.");
}
public void SortedEnumerable_ReturnWithComparer_EnumeratesSingleItem()
{
int source = 13;
ISortedEnumerable <int> result = SortedEnumerableSource.Return(source, Comparer <int> .Default);
Assert.IsTrue(result.SequenceEqual(new[] { 13 }), "Item should be enumerated.");
}
/// <summary> Returns whether the specified intervals are disjoint. </summary>
/// <param name="intervals"> The intervals to inspect, ordered by interval start. </param>
/// <returns> an empty specified enumerable is considered disjoint. </returns>
public static bool AreDisjoint(this ISortedEnumerable <Interval> intervals)
{
Contract.Requires(intervals != null);
Contract.RequiresForAll(intervals, interval => !interval.IsEmpty);
Contract.Requires(intervals.IsSorted(comparer: Compare));
Interval previous = default(Interval);
bool first = true;
foreach (Interval interval in intervals)
{
if (first)
{
first = false;
}
else
{
if (!previous.DisjointFrom(interval))
{
return(false);
}
}
previous = interval;
}
return(true);
}
public void SortedEnumerable_LastIndexOf_WithInvalidItem_DoesNotFindItem()
{
IEnumerable <string> source = new[] { "a", "a", "c" };
ISortedEnumerable <string> sorted = source.AsSorted();
int result = sorted.LastIndexOf(x => StringComparer.InvariantCultureIgnoreCase.Compare("d", x));
Assert.AreEqual(-1, result, "Item should not be found.");
}
public void SortedEnumerable_UpperBound_ItemNotFoundPastSequence_ReturnsBitwiseComplement()
{
IEnumerable <int> source = new[] { 1, 2, 2, 4 };
ISortedEnumerable <int> sorted = source.AsSorted();
int result = sorted.UpperBound(5);
Assert.AreEqual(~4, result, "LowerBound should return the bitwise complement if not found.");
}
public void SortedEnumerable_UpperBound_ItemNotFoundInEmptySequence_ReturnsBitwiseComplementOf0()
{
IEnumerable <int> source = new int[] { };
ISortedEnumerable <int> sorted = source.AsSorted();
int result = sorted.UpperBound(3);
Assert.AreEqual(~0, result, "LowerBound should return the bitwise complement if not found.");
}
public void SortedEnumerable_UpperBound_ItemFound_ReturnsUpperBound()
{
IEnumerable <int> source = new[] { 1, 2, 2, 4 };
ISortedEnumerable <int> sorted = source.AsSorted();
int result = sorted.UpperBound(2);
Assert.AreEqual(3, result, "UpperBound should return the upper bound.");
}
public void SortedEnumerable_RepeatWithComparer_RemembersComparer()
{
var comparer = Comparer <int> .Default;
int source = 13;
ISortedEnumerable <int> result = SortedEnumerableSource.Repeat(source, comparer, 3);
Assert.AreEqual(comparer, result.Comparer, "Comparer should be remembered.");
}
public void SortedEnumerable_IndexOf_WithValidItemValue_FindsItem()
{
IEnumerable <string> source = new[] { "a", "a", "c" };
ISortedEnumerable <string> sorted = source.AsSorted();
int result = sorted.IndexOf("a");
Assert.AreEqual(0, result, "Item should be found.");
}
public void SortedEnumerable_LastIndexOf_WithInvalidItemValue_DoesNotFindItem()
{
IEnumerable <string> source = new[] { "a", "a", "c" };
ISortedEnumerable <string> sorted = source.AsSorted();
int result = sorted.LastIndexOf("A");
Assert.AreEqual(-1, result, "Item should not be found.");
}
public void SortedEnumerable_IndexOf_WithValidItem_FindsItem()
{
IEnumerable <string> source = new[] { "a", "a", "c" };
ISortedEnumerable <string> sorted = source.AsSorted();
int result = sorted.IndexOf(x => StringComparer.InvariantCultureIgnoreCase.Compare("a", x));
Assert.AreEqual(0, result, "Item should be found.");
}
public void SortedEnumerable_Contains_WithInvalidItem_DoesNotFindItem()
{
IEnumerable <string> source = new[] { "a", "b", "c" };
ISortedEnumerable <string> sorted = source.AsSorted();
bool result = sorted.Contains(x => StringComparer.InvariantCultureIgnoreCase.Compare("0", x));
Assert.IsFalse(result, "Item should not be found.");
}
public void SortedEnumerable_Contains_WithInvalidItemValue_DoesNotFindItem()
{
IEnumerable <string> source = new[] { "a", "b", "c" };
ISortedEnumerable <string> sorted = source.AsSorted();
bool result = sorted.Contains("0");
Assert.IsFalse(result, "Item should not be found.");
}
public void SortedEnumerable_Contains_WithValidItemValue_FindsItem()
{
IEnumerable <string> source = new[] { "a", "b", "c" };
ISortedEnumerable <string> sorted = source.AsSorted();
bool result = sorted.Contains("b");
Assert.IsTrue(result, "Item should be found.");
}
public void SortedEnumerable_EqualRange_RunOf1_InSecondMiddle()
{
IEnumerable <int> source = new[] { 1, 3, 5, 7 };
ISortedEnumerable <int> sorted = source.AsSorted();
int begin;
int end;
sorted.EqualRange(5, out begin, out end);
Assert.AreEqual(2, begin);
Assert.AreEqual(3, end);
}
public void SortedEnumerable_EqualRange_RunOf0_InMiddle()
{
IEnumerable <int> source = new[] { 1, 3 };
ISortedEnumerable <int> sorted = source.AsSorted();
int begin;
int end;
sorted.EqualRange(2, out begin, out end);
Assert.AreEqual(1, begin);
Assert.AreEqual(1, end);
}
public void SortedEnumerable_EqualRange_RunOf3_AtBeginning()
{
IEnumerable <int> source = new[] { 1, 1, 1, 4 };
ISortedEnumerable <int> sorted = source.AsSorted();
int begin;
int end;
sorted.EqualRange(1, out begin, out end);
Assert.AreEqual(0, begin);
Assert.AreEqual(3, end);
}
public void SortedEnumerable_EqualRange_RunOf2_AtEnd()
{
IEnumerable <int> source = new[] { 1, 2, 3, 3 };
ISortedEnumerable <int> sorted = source.AsSorted();
int begin;
int end;
sorted.EqualRange(3, out begin, out end);
Assert.AreEqual(2, begin);
Assert.AreEqual(4, end);
}
public void SortedEnumerable_EqualRange_RunOf3_AtEnd()
{
IEnumerable <int> source = new[] { 0, 1, 1, 4, 4, 4 };
ISortedEnumerable <int> sorted = source.AsSorted();
int begin;
int end;
sorted.EqualRange(4, out begin, out end);
Assert.AreEqual(3, begin);
Assert.AreEqual(6, end);
}
public void SortedEnumerable_EqualRange_RunOf3_AtSecondMiddle()
{
IEnumerable <int> source = new[] { 0, 1, 4, 4, 4, 7 };
ISortedEnumerable <int> sorted = source.AsSorted();
int begin;
int end;
sorted.EqualRange(4, out begin, out end);
Assert.AreEqual(2, begin);
Assert.AreEqual(5, end);
}
public void SortedDictionary_AsSorted_EnumeratesIdenticalSequence()
{
SortedDictionary <int, string> source = new SortedDictionary <int, string>();
source.Add(0, "a");
source.Add(1, "c");
source.Add(2, "b");
ISortedEnumerable <KeyValuePair <int, string> > result = source.AsSorted();
Assert.IsTrue(result.SequenceEqual(new[] { new KeyValuePair <int, string>(0, "a"), new KeyValuePair <int, string>(1, "c"), new KeyValuePair <int, string>(2, "b") }), "AsSorted should not change the sequence.");
Assert.AreEqual(0, result.IndexOf(new KeyValuePair <int, string>(0, "a")), "Could not find item in sorted dictionary.");
}
private static IEnumerable <Gap> findGaps(ISortedEnumerable <int> filledPositionIndices, Interval toFill)
{
int previousPresentIndex = toFill.Start - 1;
foreach (int presentIndex in filledPositionIndices.ConcatIfNotLastElement(toFill.End))
{
if (presentIndex != previousPresentIndex + 1)
{
yield return(new Gap(previousPresentIndex + 1, presentIndex));
}
previousPresentIndex = presentIndex;
}
}
public static ISortedEnumerable <T> ThenBy <T, U>(this ISortedEnumerable <T> seq, Func <T, U> criterium)
where U : IComparable <U>
{
SortedEnumerable <T> s = (SortedEnumerable <T>)seq;
return(new SortedEnumerable <T>(seq,
(t1, t2) =>
{
int res = s.Criteria(t1, t2);
if (res != 0)
{
return res;
}
else
{
return criterium(t1).CompareTo(criterium(t2));
}
}
));
}
public static IEnumerable <int> RangeExcept(this ISortedEnumerable <int> sequence, int start, int end)
{
return(RangeExcept(sequence, i => i + 1, start, end));
}
/// <summary> Caches the specified sorted sequence in a sorted list. </summary>
public static SortedList <T> ToSortedList <T>(this ISortedEnumerable <T> sequence)
{
return(new SortedList <T>(sequence.ToList(), sequence.Comparer));
}
