void Difference(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output)
{
var enum1 = set1.GetEnumerator();
var enum2 = set2.GetEnumerator();
var have1 = enum1.MoveNext();
var have2 = enum2.MoveNext();
while (have1 && have2)
{
var compare = comparer.Compare(enum1.Current, enum2.Current);
if (compare < 0)
{
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
else if (compare > 0)
{
have2 = enum2.MoveNext();
}
else
{
have1 = enum1.MoveNext();
have2 = enum2.MoveNext();
}
}
while (have1)
{
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
}
private SetOp() { } // disable construction
/// <summary>
/// Computes union of two sorted sequences.
/// </summary>
/// <remarks>
/// <para>Both set1 and set2 must be sorted in ascending order with respect to comparer.</para>
/// <para>Union contains elements present in one or both ranges.</para>
/// <para>Result is written to the output iterator one member at a time</para>
///
/// <para>Union differs from <see cref="Merge">Merge</see> for multisets.</para>
///
/// <para>If k equal elements are present in set1 and m elements equal to those k
/// are present in set2,then k elements from set1 are included in the output,
/// followed by max(m-k, 0) elements from set2. The total of max(k,m) are
/// added to the output. If you'd like to have m+k elements, use Merge function.
/// </para>
/// <para>Complexity: linear on combined number of items in both sequences</para>
/// </remarks>
/// <example>
/// <para>set1 = { "a", "test", "Test", "z" }</para>
/// <para>set2 = { "b", "tEst", "teSt", "TEST", "Z" }</para>
/// <para>comparer is a case-insensitive comparer</para>
/// <para>The following elements will be added to output:
/// {"a", "b", "test", "Test", "TEST", "z" }</para>
/// </example>
public static void Union(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output) {
IEnumerator enum1 = set1.GetEnumerator();
IEnumerator enum2 = set2.GetEnumerator();
bool have1 = enum1.MoveNext();
bool have2 = enum2.MoveNext();
while (have1 && have2) {
int compare = comparer.Compare(enum1.Current, enum2.Current);
if (compare < 0) {
output.Add(enum1.Current);
have1 = enum1.MoveNext();
} else if (compare > 0) {
output.Add(enum2.Current);
have2 = enum2.MoveNext();
} else {
output.Add(enum1.Current);
have1 = enum1.MoveNext();
have2 = enum2.MoveNext();
}
}
while (have1) {
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
while (have2) {
output.Add(enum2.Current);
have2 = enum2.MoveNext();
}
}
void Inersection(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output)
{
IEnumerator enum1 = set1.GetEnumerator();
IEnumerator enum2 = set2.GetEnumerator();
bool have1 = enum1.MoveNext();
bool have2 = enum2.MoveNext();
while (have1 && have2)
{
int compare = comparer.Compare(enum1.Current, enum2.Current);
if (compare < 0)
{
have1 = enum1.MoveNext();
}
else if (compare > 0)
{
have2 = enum2.MoveNext();
}
else
{
output.Add(enum1.Current);
have1 = enum1.MoveNext();
have2 = enum2.MoveNext();
}
}
}
public OutputIteratorAdapter(IOutputIterator <From> outputIterator,
IConverter <To, From> converter)
{
this.outputIterator = outputIterator;
this.converter = converter;
}
/// <summary>
/// Computes difference of two sorted sequences.
/// </summary>
/// <remarks>
/// <para>Both set1 and set2 must be sorted in ascending order with respect to comparer.</para>
/// <para>Difference contains elements present in set1, but not in set2.</para>
/// <para>Result is written to the output iterator one member at a time</para>
///
/// <para>For multisets, if set1 contains k equal elements, and set2 contains
/// m elements equal to those k, then max(k-m,0) elements from set1 are
/// included in the output.</para>
/// <para>Complexity: linear on combined number of items in both sequences</para>
/// </remarks>
/// <example>
/// <para>set1 = {"a", "b", "test", "tEst", "z" }</para>
/// <para>set2 = {"a", "TEST", "z", "Z" }</para>
/// <para>comparer = case insensitive comparer</para>
/// <para>output = {"b", "tEst"}</para>
/// </example>
public static void Difference(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output)
{
var enum1 = set1.GetEnumerator();
var enum2 = set2.GetEnumerator();
var have1 = enum1.MoveNext();
var have2 = enum2.MoveNext();
while (have1 && have2)
{
var compare = comparer.Compare(enum1.Current, enum2.Current);
if (compare < 0)
{
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
else if (compare > 0)
{
have2 = enum2.MoveNext();
}
else
{
have1 = enum1.MoveNext();
have2 = enum2.MoveNext();
}
}
while (have1)
{
output.Add(enum1.Current);
have1 = enum1.MoveNext();
}
}
public void Insert(int index, IOutputIterator <T> item)
{
iters.Insert(index, item);
}
public int IndexOf(IOutputIterator <T> item)
{
return(iters.IndexOf(item));
}
public bool Contains(IOutputIterator <T> item)
{
return(iters.Contains(item));
}
public void Add(IOutputIterator <T> item)
{
iters.Add(item);
}
public bool Remove(IOutputIterator <T> item)
{
return(iters.Remove(item));
}
public static void Merge(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output)
{
IEnumerator enumerator = set1.GetEnumerator();
IEnumerator enumerator2 = set2.GetEnumerator();
bool flag = enumerator.MoveNext();
bool flag2 = enumerator2.MoveNext();
while (flag && flag2)
{
if (comparer.Compare(enumerator.Current, enumerator2.Current) < 0)
{
output.Add(enumerator.Current);
flag = enumerator.MoveNext();
}
else
{
output.Add(enumerator2.Current);
flag2 = enumerator2.MoveNext();
}
}
while (flag)
{
output.Add(enumerator.Current);
flag = enumerator.MoveNext();
}
while (flag2)
{
output.Add(enumerator2.Current);
flag2 = enumerator2.MoveNext();
}
}
public static void Inersection(IEnumerable set1, IEnumerable set2, IComparer comparer, IOutputIterator output)
{
IEnumerator enumerator = set1.GetEnumerator();
IEnumerator enumerator2 = set2.GetEnumerator();
bool flag = enumerator.MoveNext();
bool flag2 = enumerator2.MoveNext();
while (flag && flag2)
{
int num = comparer.Compare(enumerator.Current, enumerator2.Current);
if (num < 0)
{
flag = enumerator.MoveNext();
}
else if (num > 0)
{
flag2 = enumerator2.MoveNext();
}
else
{
output.Add(enumerator.Current);
flag = enumerator.MoveNext();
flag2 = enumerator2.MoveNext();
}
}
}
