public void Create_WithStartedIEnumerator()
{
string characters = "hello";
IEnumerator <char> enumerator = characters.GetEnumerator();
Assert.IsTrue(enumerator.MoveNext());
Iterator <char> iterator = Iterator.Create(enumerator);
Assert.IsNotNull(iterator);
Assert.IsTrue(iterator.HasStarted());
Assert.IsTrue(iterator.HasCurrent());
Assert.AreEqual('h', iterator.Current);
Assert.AreEqual('h', enumerator.Current);
foreach (char character in characters.Skip(1))
{
Assert.IsTrue(iterator.Next());
Assert.IsTrue(iterator.HasStarted());
Assert.IsTrue(iterator.HasCurrent());
Assert.AreEqual(character, iterator.Current);
Assert.AreEqual(character, enumerator.Current);
}
for (int i = 0; i < 2; ++i)
{
Assert.IsFalse(iterator.Next());
Assert.IsTrue(iterator.HasStarted());
Assert.IsFalse(iterator.HasCurrent());
Assert.ThrowsException <PreConditionException>(() => iterator.Current);
Assert.ThrowsException <InvalidOperationException>(() => enumerator.Current);
}
}
public static ISequence <ISequence <T> > Window <T>(this ISequence <T> source, int windowSize, int queueLimit = 1)
{
if (queueLimit < 1)
{
throw new ArgumentOutOfRangeException("queueLimit must be greater that one.");
}
return(Create <ISequence <T> >(context =>
{
Task <bool> lastCopyToResult = null;
var i = source.Start(context);
var subscription = new RefCountDisposable(i);
return Iterator.Create <ISequence <T> >(async(r, c) =>
{
if (lastCopyToResult != null && await lastCopyToResult.ConfigureAwait(false) == false)
{
return false;
}
if (!await i.MoveNext(c).ConfigureAwait(false))
{
return false;
}
var queue = new AsyncQueue <T>(queueLimit);
await queue.OnNext(i.Current, c).ConfigureAwait(false);
r.Value = Create(context2 => new AnonymousIterator <T>(queue.MoveNext, () => queue.Current, queue.Dispose, Enumerable.Empty <Task>, context2));
var keepAlive = subscription.GetDisposable();
lastCopyToResult = CopyToQueue(i, queue, windowSize - 1, CancellationToken.None, true).Finally(keepAlive.Dispose);
return true;
}, context, subscription);
}));
}
/// <summary>
/// Assert that the values in the provided IEnumerables are equal and in the same order.
/// </summary>
/// <typeparam name="T">The type of values to compare.</typeparam>
/// <param name="expected">The expected values.</param>
/// <param name="values">The values to check.</param>
public static void AreEqual <T>(IEnumerable <T> expected, IEnumerable <T> values)
{
if (!object.Equals(expected, values))
{
if (expected == null)
{
Assert.Fail("Expected the value to be null.");
}
else if (values == null)
{
Assert.Fail("Expected the value to be non-null.");
}
else
{
Iterator <T> valueIterator = Iterator.Create(expected);
Iterator <T> expectedIterator = Iterator.Create(values);
int index = 0;
while (valueIterator.Next() & expectedIterator.Next())
{
Assert.AreEqual(valueIterator.GetCurrent(), expectedIterator.GetCurrent(), $"Values at index {index} are not equal.");
index++;
}
if (valueIterator.HasCurrent() || expectedIterator.HasCurrent())
{
Assert.AreEqual(expected.Count(), values.Count(), "Element counts are not equal.");
}
}
}
}
public void Create_WithNonEmptyIEnumerable()
{
string characters = "hello";
Iterator <char> iterator = Iterator.Create(characters);
Assert.IsNotNull(iterator);
Assert.IsFalse(iterator.HasStarted());
Assert.IsFalse(iterator.HasCurrent());
foreach (char character in characters)
{
Assert.IsTrue(iterator.Next());
Assert.IsTrue(iterator.HasStarted());
Assert.IsTrue(iterator.HasCurrent());
Assert.AreEqual(character, iterator.Current);
}
for (int i = 0; i < 2; ++i)
{
Assert.IsFalse(iterator.Next());
Assert.IsTrue(iterator.HasStarted());
Assert.IsFalse(iterator.HasCurrent());
Assert.ThrowsException <PreConditionException>(() => iterator.Current);
}
}
//public static ISequence<R> Cast<T, R>(this ISequence<T> source)
// where T : R
//{
// return source as ISequence<R> ?? Create<R>(context =>
// {
// var iterator = source.Start(context);
// return Iterator.Create(iterator.MoveNext, () => (R)iterator.Current, iterator.Dispose, iterator.Stop, context);
// });;
//}
public static ISequence <T> Cast <T>(this ISequence source)
{
return(source as ISequence <T> ?? Create <T>(context =>
{
var iterator = source.Start(context);
return Iterator.Create(iterator.MoveNext, () => { return (T)iterator.Current; }, iterator.Dispose, iterator.Stop, context);
}));
}
public static ISequence <object> AsObjects(this ISequence source)
{
return(source as ISequence <object> ?? Create <object>(context =>
{
var iterator = source.Start(context);
return Iterator.Create(iterator.MoveNext, () => iterator.Current, iterator.Dispose, iterator.Stop, context);
}));
}
public static ISequence <T> Never <T>()
{
return(Sequence.Create <T>(context => Iterator.Create <T>(
moveNext: c => c.AsTask().Then(() => TaskConstants.CanceledTask <bool>()),
current: () => { throw new InvalidOperationException(); },
cancel: Disposable.Empty,
context: context)
));
}
public IIterator <T> Start(int queueIndex)
{
EnsureReading();
lock (gate)
{
var queue = queues[queueIndex];
if (queue == null)
{
if (readTask != null && readTask.IsCompleted)
{
if (readTask.IsFaulted)
{
return(Sequence.Throw <T>(readTask.Exception).Start(context));
}
else if (readTask.IsCanceled)
{
return(Sequence.Throw <T>(new OperationCanceledException()).Start(context));
}
else
{
return(Sequence.Empty <T>().Start(context));
}
}
queue = new AsyncQueue <T>(maxQueueLength);
queues[queueIndex] = queue;
}
if (iterators[queueIndex] != null)
{
throw new InvalidOperationException("The broadcast target already has an active iterator.");
}
var iterator = Iterator.Create(
moveNext: queue.MoveNext,
current: () => queue.Current,
cancel: () =>
{
lock (gate)
{
iterators[queueIndex] = null;
if (queue != null)
{
queue.Dispose();
queues[queueIndex] = null;
}
}
},
stop: Stop,
context: context
);
iterators[queueIndex] = iterator;
return(iterator);
}
}
public static int TestNextByteArray(byte[] a)
{
int sum = 0;
var iterator = Iterator.Create <byte>(a);
while (iterator.Next())
{
sum += iterator.Value;
}
return(sum);
}
public static int TestNextIntArrayForeach(int[] a)
{
int sum = 0;
var iterator = Iterator.Create <int>(a);
foreach (var value in iterator)
{
sum += value;
}
return(sum);
}
public static int TestNextIntArrayBase(int[] a)
{
int sum = 0;
var iterator = (Iterator)Iterator.Create <int>(a);
while (iterator.Next())
{
sum += (int)iterator.Value;
}
return(sum);
}
public static int TestNextIntArray(int[] a)
{
int sum = 0;
var iterator = Iterator <int, int> .Create(a);
while (iterator.Next())
{
sum += iterator.Value;
}
return(sum);
}
public void Create_WithEmptyIEnumerable()
{
Iterator <char> iterator = Iterator.Create("");
Assert.IsFalse(iterator.HasStarted());
Assert.IsFalse(iterator.HasCurrent());
for (int i = 0; i < 2; ++i)
{
Assert.IsFalse(iterator.Next());
Assert.IsTrue(iterator.HasStarted());
Assert.IsFalse(iterator.HasCurrent());
}
}
public static int TestConcatArray(byte[] a, byte[] b)
{
int sum = 0;
var iteratorA = Iterator <byte, byte> .Create(a);
var iteratorB = Iterator <byte, byte> .Create(b);
var iteratorC = iteratorA.Concat(iteratorB);
while (iteratorC.Next())
{
sum += iteratorC.Value;
}
return(sum);
}
public static int TestConcatMap(Map <byte, byte> a, Map <byte, byte> b)
{
int sum = 0;
var iteratorA = Iterator <byte, byte> .Create(a);
var iteratorB = Iterator <byte, byte> .Create(b);
var iteratorC = iteratorA.Concat(iteratorB);
while (iteratorC.Next())
{
sum += iteratorC.Key;
sum += iteratorC.Value;
}
return(sum);
}
public static int TestConcatValues(Map <byte, byte> a, Map <byte, byte> b)
{
int sum = 0;
var iteratorA = Iterator <byte, byte> .Create(a);
var iteratorB = Iterator <byte, byte> .Create(b);
var iteratorC = iteratorA.Concat(iteratorB);
var enumerator = iteratorC.Values;
while (enumerator.Next())
{
sum += enumerator.Value;
}
return(sum);
}
public static ISequence <T> CreateProducer <T>(Func <IAsyncObserver <T>, CancellationToken, Task> producer, int queueLimit)
{
return(Create(context =>
{
var cts = new CancellationTokenSource();
var queue = new AsyncQueue <T>(queueLimit);
var task = producer(queue, cts.Token)
.ContinueWith(t => queue.OnError(t.Exception), TaskContinuationOptions.OnlyOnFaulted);
return Iterator.Create(
moveNext: queue.MoveNext,
current: () => queue.Current,
cancel: cts.Cancel,
stop: () => EnumerableEx.Return(task),
context: context
);
}));
}
public void Create_WithFinishedIEnumerator()
{
string characters = "";
IEnumerator <char> enumerator = characters.GetEnumerator();
Assert.IsFalse(enumerator.MoveNext());
Iterator <char> iterator = Iterator.Create(enumerator);
Assert.IsNotNull(iterator);
Assert.IsTrue(iterator.HasStarted());
Assert.IsFalse(iterator.HasCurrent());
Assert.ThrowsException <PreConditionException>(() => iterator.Current);
Assert.ThrowsException <InvalidOperationException>(() => enumerator.Current);
for (int i = 0; i < 2; ++i)
{
Assert.IsFalse(iterator.Next());
Assert.IsTrue(iterator.HasStarted());
Assert.IsFalse(iterator.HasCurrent());
Assert.ThrowsException <PreConditionException>(() => iterator.Current);
Assert.ThrowsException <InvalidOperationException>(() => enumerator.Current);
}
}
public static object GetIterator()
{
var iteratorA = Iterator <BigInteger, BigInteger> .Create(new BigInteger[] { -10 });
return(iteratorA);
}
public void Create_WithNullIEnumerator()
{
Assert.ThrowsException <PreConditionException>(() => Iterator.Create((IEnumerator <char>)null));
}
public static object IteratorTest(byte[] a, byte[] b)
{
int sum = 0;
var iterator = Iterator <byte, byte> .Create(a);
while (iterator.Next())
{
sum += iterator.Value;
}
OnNotify("aa", sum);
sum = 1;
var iteratorA = Iterator <byte, byte> .Create(a);
var iteratorB = Iterator <byte, byte> .Create(b);
var iteratorC = iteratorA.Concat(iteratorB);
while (iteratorC.Next())
{
sum += iteratorC.Key;
sum += iteratorC.Value;
}
OnNotify(sum);
Map <byte, byte> map = new Map <byte, byte>();
map[2] = 12;
map[0] = 24;
map[1] = 10;
map[12] = 36;
Map <byte, byte> map1 = new Map <byte, byte>();
map1[2] = 12;
map1[0] = 24;
map1[1] = 10;
map1[12] = 36;
sum = 0;
var iteratorD = Iterator <byte, byte> .Create(map);
var iteratorE = Iterator <byte, byte> .Create(map1);
var iteratorF = iteratorD.Concat(iteratorE);
var enumerator = iteratorF.Keys;
while (enumerator.Next())
{
sum += enumerator.Value;
}
OnNotify(sum);//30
sum = 0;
var iteratorH = Iterator <byte, byte> .Create(map);
var iteratorI = Iterator <byte, byte> .Create(map1);
var iteratorG = iteratorH.Concat(iteratorI);
var enumeratorV = iteratorG.Values;
while (enumeratorV.Next())
{
sum += enumeratorV.Value;
}
OnNotify(sum);//164
OnNotify(iteratorA);
OnNotify(iteratorA.Values);
OnNotify(iteratorA.Keys);
return(iteratorA.Keys);
}
public static ISequence <T> Create <T>(Func <IObserver <T>, CancellationToken, Task> start)
{
return(Create(context => Iterator.Create(start, context)));
}
