/// <summary>
///
///
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public ListBounded <T> SubsetNotIn(ListBounded <T> other, ref T[] scratchBuffer)
{
if (scratchBuffer == null || scratchBuffer.Length < other.MaxLength)
{
scratchBuffer = new T[other.MaxLength];
}
int countThis = Count;
int countOther = other.Count;
// Make a copy of the other buffer and sort the copy
Array.Copy(other.array, scratchBuffer, countOther);
Array.Sort(scratchBuffer, 0, countOther);
ListBounded <T> ret = new ListBounded <T>(Count);
for (int i = 0; i < countThis; i++)
{
T item = this[i];
// Search other array for this item, and add to our return list if not found
if (Array.BinarySearch(scratchBuffer, 0, countOther, item) < 0)
{
ret.Add(item);
}
}
return(ret);
}
/// <summary>
///
///
/// NOTE: this is destructive because it sorts the array sunderlying both ListBounded.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public ListBounded <T> SubsetNotInOLD(ListBounded <T> other)
{
Array.Sort(array, 0, Count);
Array.Sort(other.array, 0, other.Count);
int len2 = other.Count;
int pos2 = 0;
ListBounded <T> ret = new ListBounded <T>(Count);
for (int i = 0; i < Count; i++)
{
T item = this[i];
while (pos2 < len2 && other[pos2].CompareTo(item) == -1)
{
pos2++;
}
if (pos2 == len2 || other[pos2].CompareTo(item) == 1)
{
ret.Add(item);
}
}
return(ret);
}
internal Enumerator(ListBounded <T> list)
{
this.list = list;
index = 0;
version = list.version;
current = default(T);
}
// --------------------------------------------------------------------------------------------
/// <summary>
/// Returns a new ListBounded which represents the union of items (including possible duplicates).
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public ListBounded <T> UnionWith(ListBounded <T> other)
{
ListBounded <T> ret = new ListBounded <T>(Count + other.Count);
Array.Copy(array, ret.array, Count);
Array.Copy(other.array, 0, ret.array, Count, other.Count);
return(ret);
}
/// <summary>
/// Returns a new ListBounded which represents the (sorted) union of items (excluding duplicates).
///
/// NOTE: this is destructive because it sorts the array sunderlying both ListBounded.
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public ListBounded <T> UnionDistinctWith(ListBounded <T> other)
{
Array.Sort(array, 0, Count);
Array.Sort(other.array, 0, other.Count);
int len1 = this.Count;
int len2 = other.Count;
int pos1 = 0;
int pos2 = 0;
ListBounded <T> ret = new ListBounded <T>(len1 + len2);
while (pos1 < len1 || pos2 < len2)
{
if (pos1 == len1)
{
ret.Add(other[pos2++]);
}
else if (pos2 == len2)
{
ret.Add(this[pos1++]);
}
else
{
T try1 = this[pos1];
T try2 = other[pos2];
int compareResult = try1.CompareTo(try2);
if (compareResult == 0)
{
ret.Add(try1);
pos1++;
pos2++;
}
else if (compareResult == -1)
{
ret.Add(try1);
pos1++;
}
else if (compareResult == 1)
{
ret.Add(try2);
pos2++;
}
else
{
Debug.Assert(false);
}
}
}
return(ret);
}
public bool MoveNext()
{
ListBounded <T> localArray = list;
if (version == localArray.version && ((uint)index < (uint)localArray.length))
{
current = localArray.array[index];
index++;
return(true);
}
return(MoveNextRare());
}
public ListBounded(ListBounded <T> other, StorageMode storageMode = StorageMode.AllocatedArray)
{
DoCreate(other.Count, storageMode);
length = other.Count;
Array.Copy(other.array, array, other.Count);
}
public void Set(ListBounded <T> items)
{
length = items.Count;
Array.Copy(items.array, array, items.Count);
version++;
}
/// <summary>
/// Adds a specified ListBounded of items to the array
/// </summary>
/// <param name="t"></param>
public void Add(ListBounded <T> t, int maxElements = int.MaxValue)
{
version++;
Array.Copy(t.array, 0, array, length, System.Math.Min(t.Count, maxElements));
length += t.Count;
}
