public static void GenerateN <T>(OutputIterator <T> begin, int count, Functional.GenFunction <T> func)
{
for (begin = IteratorUtil.Clone(begin); count > 0; --count, begin.MoveNext())
{
begin.Write(func());
}
}
public static OutputIterator <T> FillN <T>(OutputIterator <T> begin, int count, T value)
{
for (begin = IteratorUtil.Clone(begin); count > 0; --count, begin.MoveNext())
{
begin.Write(value);
}
return(begin);
}
public static void CopyN <T>(InputIterator <T> begin, uint count, OutputIterator <T> target)
{
for (begin = IteratorUtil.Clone(begin), target = IteratorUtil.Clone(target); count > 0; --count)
{
target.Write(begin.Read());
begin.MoveNext();
target.MoveNext();
}
}
public static OutputIterator <T> Copy <T>(IEnumerable <T> enumerable, OutputIterator <T> target)
{
target = IteratorUtil.Clone(target);
foreach (T t in enumerable)
{
target.Write(t);
target.MoveNext();
}
return(target);
}
[Test] public void UniqueCopy_List_OutputIterator()
{
OutputIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
OutputIterator <int> result = Algorithm.UniqueCopy(src, destIter);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, (result as ListIterator <int>).Position);
Assert.AreEqual(Int32.MinValue, (result as ListIterator <int>).Read());
}
[Test] public void UniqueCopy_Predicate_OutputIterator()
{
OutputIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
OutputIterator <int> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, delegate(int lhs, int rhs) { return(lhs == rhs); });
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, (result as ListIterator <int>).Position);
Assert.AreEqual(Int32.MinValue, (result as ListIterator <int>).Read());
}
[Test] public void RemoveCopy_List_OutputIterator_Comparer()
{
OutputIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
OutputIterator <int> result = Algorithm.RemoveCopy(src, destIter, 29, EqualityComparer <int> .Default);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(src.Length - 3, (result as ListIterator <int>).Position);
}
public static OutputIterator <O> Transform <I, O>(InputIterator <I> begin1, InputIterator <I> end1, InputIterator <I> begin2,
OutputIterator <O> dest, Functional.BinaryFunction <I, I, O> func)
{
begin1 = IteratorUtil.Clone(begin1);
begin2 = IteratorUtil.Clone(begin2);
dest = IteratorUtil.Clone(dest);
for (; !begin1.Equals(end1); begin1.MoveNext(), begin2.MoveNext(), dest.MoveNext())
{
dest.Write(func(begin1.Read(), begin2.Read()));
}
return(dest);
}
[Test] public void RemoveCopyIf_OutputIterator()
{
OutputIterator <int> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
OutputIterator <int> result = Algorithm.RemoveCopyIf(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, Is29);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(src.Length - 3, (result as ListIterator <int>).Position);
}
[Test] public void UniqueCopy_OutputIterator()
{
OutputIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
OutputIterator <string> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter);
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, (result as ListIterator <string>).Position);
Assert.AreEqual(MARKER, (result as ListIterator <string>).Read());
}
[Test] public void UniqueCopy_Predicate_OutputIterator()
{
OutputIterator <string> destIter = IteratorUtil.Begin(dest);
destIter.MoveNext();
OutputIterator <string> result = Algorithm.UniqueCopy(IteratorUtil.Begin(src), IteratorUtil.End(src), destIter, delegate(string lhs, string rhs) { return(lhs == rhs); });
VerifyOutput();
Assert.IsNotNull(result);
Assert.AreEqual(6, (result as ListIterator <string>).Position);
Assert.AreEqual(MARKER, (result as ListIterator <string>).Read());
}
public static void CopyN <T>(IEnumerable <T> enumerable, uint count, OutputIterator <T> target)
{
if (count == 0)
{
return;
}
target = IteratorUtil.Clone(target);
foreach (T t in enumerable)
{
target.Write(t);
target.MoveNext();
--count;
if (count == 0)
{
return;
}
}
}
[Test] public void FillN_Iterator()
{
int[] array = new int[10];
ListIterator <int> begin = IteratorUtil.Begin(array);
ListIterator <int> end = IteratorUtil.End(array);
begin.MoveNext();
end.MovePrev();
OutputIterator <int> result = Algorithm.FillN(begin, 8, 42);
Assert.AreEqual(0, array[0]);
Assert.AreEqual(0, array[array.Length - 1]);
for (int i = 1; i < array.Length - 1; ++i)
{
Assert.AreEqual(42, array[i]);
}
Assert.IsNotNull(result);
Assert.IsInstanceOfType(typeof(ListIterator <int>), result);
Assert.AreEqual(9, (result as ListIterator <int>).Position);
}
public static void RotateCopy <T>(ForwardIterator <T> begin, ForwardIterator <T> middle,
ForwardIterator <T> end, OutputIterator <T> dest)
{
Copy(begin, middle, Copy(middle, end, dest));
#if NEVER
dest = IteratorUtil.Clone(dest);
ForwardIterator <T> src = IteratorUtil.Clone(newBegin);
newBegin = IteratorUtil.Clone(newBegin);
for (; !src.Equals(end); dest.MoveNext(), src.MoveNext())
{
dest.Write(src.Read());
}
src = IteratorUtil.Clone(begin);
for (; !src.Equals(newBegin); dest.MoveNext(), src.MoveNext())
{
dest.Write(src.Read());
}
#endif
}
public static OutputIterator <T> UniqueCopy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> dest, Functional.BinaryPredicate <T> func)
{
if (begin.Equals(end))
{
return(null);
}
begin = IteratorUtil.Clone(begin);
dest = IteratorUtil.Clone(dest);
T t = begin.Read();
dest.Write(t);
dest.MoveNext();
begin.MoveNext();
for (; !begin.Equals(end); begin.MoveNext())
{
T next = begin.Read();
if (!func(t, next))
{
t = next;
dest.Write(next);
dest.MoveNext();
}
}
return(dest);
}
public static OutputIterator <T> UniqueCopy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> dest, IEqualityComparer <T> comparer)
{
if (begin.Equals(end))
{
return(null);
}
begin = IteratorUtil.Clone(begin);
dest = IteratorUtil.Clone(dest);
T t = begin.Read();
dest.Write(t);
dest.MoveNext();
begin.MoveNext();
for (; !begin.Equals(end); begin.MoveNext())
{
T next = begin.Read();
if (!comparer.Equals(t, next))
{
t = next;
dest.Write(next);
dest.MoveNext();
}
}
return(dest);
}
public static OutputIterator <T> UniqueCopy <T>(IList <T> source, OutputIterator <T> dest, Functional.BinaryPredicate <T> func)
{
return(UniqueCopy(IteratorUtil.Begin(source), IteratorUtil.End(source), dest, func));
}
public static OutputIterator <T> UniqueCopy <T>(IList <T> source, OutputIterator <T> dest, IEqualityComparer <T> comparer)
{
return(UniqueCopy(IteratorUtil.Begin(source), IteratorUtil.End(source), dest, comparer));
}
public static OutputIterator <T> Copy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> target)
{
for (begin = IteratorUtil.Clone(begin), target = IteratorUtil.Clone(target);
!begin.Equals(end);
begin.MoveNext(), target.MoveNext())
{
target.Write(begin.Read());
}
return(target);
}
public static OutputIterator <T> RemoveCopy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> dest, T value, IEqualityComparer <T> comparer)
{
for (begin = IteratorUtil.Clone(begin), dest = IteratorUtil.Clone(dest); !begin.Equals(end); begin.MoveNext())
{
T t = begin.Read();
if (!comparer.Equals(value, t))
{
dest.Write(t);
dest.MoveNext();
}
}
return(dest);
}
public static void ReplaceCopy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> dest, T oldValue, T newValue, IEqualityComparer <T> comparer)
{
for (begin = IteratorUtil.Clone(begin), dest = IteratorUtil.Clone(dest); !begin.Equals(end); begin.MoveNext(), dest.MoveNext())
{
T srcValue = begin.Read();
if (comparer.Equals(oldValue, srcValue))
{
dest.Write(newValue);
}
else
{
dest.Write(srcValue);
}
}
}
/// <summary>
/// Reverses elements from a source enumerable to an output iterator in reverse order
/// </summary>
/// <remarks>
/// Because .NET does not allow use to traverse an enumerator in reverse, we have to create a complete, temporary
/// copy of the input collection. This is terribly inefficient. Beware when using this routine with large collections.
/// </remarks>
/// <typeparam name="T"></typeparam>
/// <param name="enumerable"></param>
/// <param name="target"></param>
public static void ReverseCopy <T>(IEnumerable <T> enumerable, OutputIterator <T> target)
{
ReverseCopy(new List <T>(enumerable), target);
}
public static void ReverseCopy <T>(IList <T> source, OutputIterator <T> target)
{
ReverseCopy(IteratorUtil.Begin(source), IteratorUtil.End(source), target);
}
public static OutputIterator <T> RemoveCopy <T>(IList <T> source, OutputIterator <T> dest, T value, IEqualityComparer <T> comparer)
{
return(RemoveCopy(IteratorUtil.Begin(source), IteratorUtil.End(source), dest, value, comparer));
}
public static OutputIterator <T> RemoveCopy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> dest, T value)
where T : IEquatable <T>
{
for (begin = IteratorUtil.Clone(begin), dest = IteratorUtil.Clone(dest); !begin.Equals(end); begin.MoveNext())
{
T t = begin.Read();
if (!value.Equals(t))
{
dest.Write(t);
dest.MoveNext();
}
}
return(dest);
}
public static void ReplaceCopy <T>(IList <T> list, OutputIterator <T> dest, T oldValue, T newValue, IEqualityComparer <T> comparer)
where T : IEquatable <T>
{
ReplaceCopy(IteratorUtil.Begin(list), IteratorUtil.End(list), dest, oldValue, newValue, comparer);
}
public static OutputIterator <T> RemoveCopy <T>(IList <T> source, OutputIterator <T> dest, T value)
where T : IEquatable <T>
{
return(RemoveCopy(IteratorUtil.Begin(source), IteratorUtil.End(source), dest, value));
}
public static OutputIterator <T> UniqueCopy <T>(IList <T> source, OutputIterator <T> dest)
where T : IEquatable <T>
{
return(UniqueCopy(IteratorUtil.Begin(source), IteratorUtil.End(source), dest));
}
public static void ReplaceCopy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> dest, T oldValue, T newValue)
where T : IEquatable <T>
{
ReplaceCopy(begin, end, dest, oldValue, newValue, EqualityComparer <T> .Default);
}
public static OutputIterator <T> UniqueCopy <T>(InputIterator <T> begin, InputIterator <T> end, OutputIterator <T> dest)
where T : IEquatable <T>
{
return(UniqueCopy(begin, end, dest, EqualityComparer <T> .Default));
}
