/// <summary>
/// Determines whether the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> overlaps with the specified collection.
/// </summary>
/// <param name="other">The collection to compare to the current set.</param>
/// <returns>true if the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> and <paramref name="other"/> share at least one common element; otherwise, false.</returns>
public bool Overlaps(IEnumerable <T> other)
{
if (other == null)
{
Thrower.ArgumentNullException(ArgumentType.other);
}
if (Count == 0)
{
return(false);
}
if (CollectionHelper.IsWellKnownCollection <T>(other, out int num))
{
if (num == 0)
{
return(false);
}
ICommonSortedSet <T> sortedset = SetHelper <T> .GetSortedSetIfSameComparer(this, Comparer);
if (sortedset != null)
{
if ((_comparer.Compare(MinValue, sortedset.MaxValue) > 0) || (_comparer.Compare(MaxValue, sortedset.MinValue) < 0))
{
return(false);
}
}
foreach (T item in other)
{
if (Contains(item))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Determines whether the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> and the specified collection contain the same elements.
/// </summary>
/// <param name="other">The collection to compare to the current set.</param>
/// <returns>true if the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> is equal to <paramref name="other"/>; otherwise, false.</returns>
public bool SetEquals(IEnumerable <T> other)
{
if (other == null)
{
Thrower.ArgumentNullException(ArgumentType.other);
}
ICommonSortedSet <T> sortedset = SetHelper <T> .GetSortedSetIfSameComparer(this, Comparer);
if (sortedset != null)
{
IEnumerator <T> e1 = this.GetEnumerator();
IEnumerator <T> e2 = sortedset.GetEnumerator();
bool canMove1 = e1.MoveNext();
bool canMove2 = e2.MoveNext();
while (canMove1 && canMove2)
{
if (_comparer.Compare(e1.Current, e2.Current) != 0)
{
return(false);
}
canMove1 = e1.MoveNext();
canMove2 = e2.MoveNext();
}
return(canMove1 == canMove2);
}
return(SetHelper <T> .SetEquals(this, other));
}
/// <summary>
/// Determines whether the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> is a subset of a specified collection.
/// </summary>
/// <param name="other">The collection to compare to the current set.</param>
/// <returns>true if the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> is a subset of the specified collection; otherwise, false.</returns>
public bool IsSubsetOf(IEnumerable <T> other)
{
if (other == null)
{
Thrower.ArgumentNullException(ArgumentType.other);
}
if (this.Count == 0)
{
return(true);
}
ICommonSortedSet <T> sortedset = SetHelper <T> .GetSortedSetIfSameComparer(this, Comparer);
if (sortedset != null)
{
if (this.Count > sortedset.Count)
{
return(false);
}
ICommonSortedSet <T> subset = sortedset.GetViewBetween(MinValue, MaxValue);
foreach (T item in this)
{
if (!subset.Contains(item))
{
return(false);
}
}
return(true);
}
return(SetHelper <T> .IsSubsetOf(this, other));
}
public ReadOnlyCollectionProxy(IReadOnlyCollection <T> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
this.collection = collection;
}
/// <summary>
/// Returns an <see cref="T:Academy.Collections.Generic.ISortedCollection`1"/> implementation based on the specified <see cref="T:System.Collections.Generic.SortedSet`1"/>.
/// </summary>
/// <typeparam name="T">The type of elements in the sorted set.</typeparam>
/// <param name="collection">The sorted set to wrap in the <see cref="T:Academy.Collections.Generic.ISortedCollection`1"/> implementation.</param>
/// <returns>a <see cref="T:Academy.Collections.Generic.ISortedCollection`1"/> implementation that wraps the specified sorted set.</returns>
public static ISortedCollection <T> AsSortedCollection <T>(SortedSet <T> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
return(new SortedSetWrapper <T>(collection));
}
/// <summary>
/// Returns an <see cref="T:Academy.Collections.Generic.IMatrix`1"/> implementation based on the specified two dimensional <see cref="T:System.Array"/>.
/// </summary>
/// <typeparam name="T">The type of elements in the array.</typeparam>
/// <param name="array">The array to wrap.</param>
/// <returns>a <see cref="T:Academy.Collections.Generic.IMatrix`1"/> implementation that wraps the specified two dimensional array.</returns>
public static IMatrix <T> AsMatrix <T>(T[,] array)
{
if (array == null)
{
Thrower.ArgumentNullException(ArgumentType.array);
}
return(new ArrayGenericMatrix <T>(array));
}
/// <summary>
/// Returns the specified <see cref="T:System.Collections.Generic.IReadOnlyCollection`1"/> wrapped in a read-only <see cref="T:System.Collections.Generic.ICollection`1"/>.
/// </summary>
/// <typeparam name="T">The type of elements in the read-only collection.</typeparam>
/// <param name="collection">The read-only collection to wrap.</param>
/// <returns>Returns a read-only <see cref="T:System.Collections.Generic.ICollection`1"/> wrapper of the specified read-only collection.</returns>
public static ICollection <T> AsCollection <T>(IReadOnlyCollection <T> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
return(new CompatibleCollection <T>(collection));
}
/// <summary>
/// Returns the specified <see cref="T:System.Collections.Generic.IReadOnlyList`1"/> wrapped in a read-only <see cref="T:System.Collections.Generic.IList`1"/>.
/// </summary>
/// <typeparam name="T">The type of elements in the read-only list.</typeparam>
/// <param name="list">The read-only list to wrap.</param>
/// <returns>Returns a read-only <see cref="T:System.Collections.Generic.IList`1"/> wrapper of the specified read-only list.</returns>
public static IList <T> AsList <T>(IReadOnlyList <T> list)
{
if (list == null)
{
Thrower.ArgumentNullException(ArgumentType.list);
}
return(new CompatibileList <T>(list));
}
public MatrixProxy(IMatrix <T> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
this.collection = collection;
}
/// <summary>
/// Removes a specified value from the <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/> by searching every element that matches the value by using the
/// <see cref="T:System.Collections.Generic.IComparer`1"/> implementation provided by the Comparer property, and the specified <see cref="T:System.Predicate`1"/>.
/// </summary>
/// <param name="value">The value to locate in the list.</param>
/// <param name="match">The predicate used to determinate if an element exists.</param>
/// <returns>true if any value matches both, the <see cref="T:System.Collections.Generic.IComparer`1"/> provided by the Comparer property and the specified <see cref="T:System.Predicate`1"/> and the found value was also successfully removed.</returns>
public bool Remove(T value, Predicate <T> match)
{
if (match == null)
{
Thrower.ArgumentNullException(ArgumentType.match);
}
return(InternalRemove(value, match));
}
public EnumerableProxy(IEnumerable <T> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
this.collection = collection;
}
/// <summary>
/// Returns the specified <see cref="T:System.Collections.Generic.IReadOnlyDictionary`2"/> wrapped in a read-only <see cref="T:System.Collections.Generic.IDictionary`2"/>.
/// </summary>
/// <typeparam name="TKey">The type of _keys in the dictionary.</typeparam>
/// <typeparam name="TValue">The type of values in the dictionary.</typeparam>
/// <param name="dictionary">The read-only dictionary to wrap.</param>
/// <returns>Returns a read-only <see cref="T:System.Collections.Generic.IDictionary`2"/> wrapper of the specified read-only dictionary.</returns>
public static IDictionary <TKey, TValue> AsDictionary <TKey, TValue>(IReadOnlyDictionary <TKey, TValue> dictionary)
{
if (dictionary == null)
{
Thrower.ArgumentNullException(ArgumentType.dictionary);
}
return(new CompatibleDictionary <TKey, TValue>(dictionary));
}
public LookupProxy(ILookup <TKey, TValue> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
this.collection = collection;
}
void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
Thrower.ArgumentNullException(ArgumentType.info);
}
info.AddValue(SerializationString.Collection, _heap);
info.AddValue(SerializationString.Index, _index);
info.AddValue(SerializationString.Version, _version);
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
Thrower.ArgumentNullException(ArgumentType.info);
}
info.AddValue(SerializationString.Collection, _underlying, typeof(ReadOnlySortedSet <T>));
info.AddValue(SerializationString.LowerIndex, _lowerIndex);
info.AddValue(SerializationString.UpperIndex, _upperIndex);
}
protected override void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
Thrower.ArgumentNullException(ArgumentType.info);
}
info.AddValue(SerializationString.Max, _max);
info.AddValue(SerializationString.Min, _min);
base.GetObjectData(info, context);
}
/// <summary>
/// Initialize a new instance of the <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/> class that contains
/// elements copied from the especified collection and that uses a specified comparer.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the new <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/>.</param>
/// <param name="comparer">The default comparer to use for compare objects.</param>
public SortedLinkedList(IEnumerable <T> collection, IComparer <T> comparer)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
_random = new Random();
this._comparer = comparer ?? Comparer <T> .Default;
ReconstructFrom(collection);
}
/// <summary>
/// Initialize a new instance of the <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> class that contains
/// elements copied from the especified collection and that uses a specified comparer.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the new <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/>.</param>
/// <param name="comparer">The default comparer to use for compare objects.</param>
public ReadOnlySortedSet(IEnumerable <T> collection, IComparer <T> comparer)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
this._comparer = comparer ?? Comparer <T> .Default;
List <T> list = SetHelper <T> .GetSortedListSet(collection, this._comparer);
this._elements = list.ToArray();
}
/// <summary>
/// Creates a new instance of <see cref="T:Academy.Collections.Generic.MatrixEntryCollection`1"/> that contains
/// elements copied from the specified collection and sorted by the specified order.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the new <see cref="T:Academy.Collections.Generic.MatrixEntryCollection`1"/>.</param>
/// <param name="order">The order the collection presents the entries.</param>
/// <returns>a new instance of <see cref="T:Academy.Collections.Generic.MatrixEntryCollection`1"/> containing elements copied from the specified collection
/// and provides the specified order.</returns>
public static MatrixEntryCollection <T> Create(IEnumerable <MatrixEntry <T> > collection, MatrixDataOrder order)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
if (order == MatrixDataOrder.Default)
{
order = MatrixDataOrder.Row;
}
return(new EntryFixedCollection(collection, order));
}
public static void CopyToCheck <T>(T[] array, int index, int count)
{
if (array == null)
{
Thrower.ArgumentNullException(ArgumentType.array);
}
if (index < 0 || index > array.Length)
{
Thrower.ArgumentOutOfRangeException(ArgumentType.index, string.Format(Resources.ArgumentOutOfRange_Range_G, new object[] { 0, array.Length - 1 }));
}
if (array.Length - index < count)
{
Thrower.ArgumentException(ArgumentType.index, Resources.Argument_ArrayNotLongEnought);
}
}
/// <summary>
/// Removes all the values that match the conditions defined by the specified predicate from a <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/>.
/// </summary>
/// <param name="match">The delegate that defines the conditions of the elements to remove.</param>
/// <returns>The number of elements that were removed from the <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/> collection.</returns>
public int RemoveWhere(Predicate <T> match)
{
if (match == null)
{
Thrower.ArgumentNullException(ArgumentType.match);
}
List <T> matchesList = new List <T>(Count);
ListWalk(x =>
{
if (match(x.Value))
{
matchesList.Add(x.Value);
}
return(true);
});
return(matchesList.Count(InternalRemove));
}
public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
Thrower.ArgumentNullException(ArgumentType.info);
}
info.AddValue(SerializationString.Version, version);
info.AddValue(SerializationString.Comparer, comparer, typeof(IEqualityComparer <T>));
int size = (indices == null) ? 0 : indices.Length;
info.AddValue(SerializationString.IndicesCount, size);
if (indices != null)
{
T[] array = new T[Count];
CopyTo(array, 0);
info.AddValue(SerializationString.Data, array, typeof(T[]));
}
}
/// <summary>
/// Determines whether an element is in the <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/> by searching every element that matches the specified value by using the
/// <see cref="T:System.Collections.Generic.IComparer`1"/> implementation provided by the Comparer property, and the specified <see cref="T:System.Predicate`1"/>.
/// </summary>
/// <param name="value">The first value to locate in the list.</param>
/// <param name="match">The predicate used to determinate if an element exists.</param>
/// <returns>true if any value matches both, the <see cref="T:System.Collections.Generic.IComparer`1"/> provided by the Comparer property and the specified <see cref="T:System.Predicate`1"/>.</returns>
public bool Contains(T value, Predicate <T> match)
{
if (match == null)
{
Thrower.ArgumentNullException(ArgumentType.match);
}
if (IsInRange(value))
{
Node current = _head;
Node node = null;
for (int i = _head.Count - 1; i >= 0; i--)
{
while (current.Nodes[i] != null && IsInRange(current.Nodes[i].Value))
{
int results = this._comparer.Compare(current.Nodes[i].Value, value);
if (results < 0)
{
current = current.Nodes[i];
}
else
{
if (results == 0)
{
if (match(current.Nodes[i].Value))
{
return(true);
}
node = current.Nodes[i];
}
break;
}
}
}
while ((node != null) && (this._comparer.Compare(node.Value, value) == 0))
{
if (match(node.Value))
{
return(true);
}
node = node.Nodes[0];
}
}
return(false);
}
/// <summary>
/// Implements the <see cref="T:System.Runtime.Serialization.ISerializable"/> interface and returns the data that you must have to serialize an <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/> object.
/// </summary>
/// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that contains the information that is required to serialize the <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/> object.</param>
/// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> structure that contains the source and destination of the serialized stream associated with the <see cref="T:Academy.Collections.Generic.SortedLinkedList`1"/> object.</param>
protected virtual void GetObjectData(SerializationInfo info, StreamingContext context)
{
if (info == null)
{
Thrower.ArgumentNullException(ArgumentType.info);
}
info.AddValue(SerializationString.Version, _version);
info.AddValue(SerializationString.Count, _count);
info.AddValue(SerializationString.Comparer, _comparer, typeof(IComparer <T>));
if (_count != 0)
{
T[] local = new T[Count];
int index = 0;
foreach (T item in this)
{
local[index++] = item;
}
info.AddValue(SerializationString.Data, local, typeof(T[]));
}
}
public void FillWith(IEnumerable <T> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
int num = 0;
if (isRow)
{
foreach (var item in collection.Take(matrix.colDim))
{
matrix.DirectlySet(containedIndex, num++, item);
}
}
else
{
foreach (var item in collection.Take(matrix.rowDim))
{
matrix.DirectlySet(num++, containedIndex, item);
}
}
}
public static void CopyToCheck(Array array, int index, int count)
{
if (array == null)
{
Thrower.ArgumentNullException(ArgumentType.array);
}
if (array.Rank != 1)
{
Thrower.ArgumentException(ArgumentType.array, Resources.Argument_ArrayRank);
}
if (array.GetLowerBound(0) != 0)
{
Thrower.ArgumentException(ArgumentType.array, Resources.Argument_LowerBoundArrayNotZero);
}
if (index < 0 || index > array.Length)
{
Thrower.ArgumentOutOfRangeException(ArgumentType.index, string.Format(Resources.ArgumentOutOfRange_Range_G, new object[] { 0, array.Length - 1 }));
}
if ((array.Length - index) < count)
{
Thrower.ArgumentException(ArgumentType.empty, Resources.Argument_ArrayNotLongEnought);
}
}
/// <summary>
/// Determines whether the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> is a superset of a specified collection.
/// </summary>
/// <param name="other">The collection to compare to the current set.</param>
/// <returns>true if the current <see cref="T:Academy.Collections.Generic.ReadOnlySortedSet`1"/> is a superset of <paramref name="other"/>; otherwise, false.</returns>
public bool IsSupersetOf(IEnumerable <T> other)
{
if (other == null)
{
Thrower.ArgumentNullException(ArgumentType.other);
}
if (CollectionHelper.IsWellKnownCollection(other, out int num))
{
if (num == 0)
{
return(true);
}
if (SetHelper <T> .IsWellKnownSet(other))
{
if (this.Count < num)
{
return(false);
}
}
}
ICommonSortedSet <T> sortedset = SetHelper <T> .GetSortedSet(other);
if ((sortedset == null) || !AreEqualComparers(this._comparer, sortedset.Comparer))
{
return(this.ContainsSequence(other));
}
ReadOnlySortedSet <T> subset = this.GetViewBetween(sortedset.MinValue, sortedset.MaxValue);
foreach (T item in sortedset)
{
if (!subset.Contains(item))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Initialize a new instance of the <see cref="T:Academy.Collections.Generic.PriorityQueue`1"/> class that contains
/// elements copied from the especified collection and uses the specified comparer.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the new <see cref="T:Academy.Collections.Generic.PriorityQueue`1"/>.</param>
/// <param name="comparer">The default comparer to use for compare objects.</param>
public PriorityQueue(IEnumerable <T> collection, IComparer <T> comparer)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
if (comparer == null)
{
comparer = Comparer <T> .Default;
}
_comparer = comparer;
if (collection is PriorityQueue <T> heap && _comparer.Equals(heap.Comparer))
{
_elements = heap._elements.Clone() as T[];
_currentIndex = heap._currentIndex;
}
else
{
if (!CollectionHelper.IsWellKnownCollection(collection, out int num))
{
num = DefaultCapacity;
}
_elements = new T[num + 1];
_comparer = comparer;
_currentIndex = 1;
_elements[0] = default(T);
using (IEnumerator <T> enumerator = collection.GetEnumerator())
{
while (enumerator.MoveNext())
{
Enqueue(enumerator.Current);
}
}
TrimExcess();
}
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="T:Academy.Collections.Generic.EndlessQueue`1"/>
/// class that contains elements copied from the specified collection.
/// </summary>
/// <param name="collection">The collection whose elements are copied to the <see cref="T:Academy.Collections.Generic.EndlessQueue`1"/>.</param>
public EndlessQueue(IEnumerable <T> collection)
{
if (collection == null)
{
Thrower.ArgumentNullException(ArgumentType.collection);
}
if (!CollectionHelper.IsWellKnownCollection(collection, out int size))
{
size = DefSize;
}
this.head = 0;
this.tail = 0;
this.items = new T[DefSize];
this.count = 0;
foreach (var item in collection)
{
if (this.Count == Capacity)
{
Capacity = Capacity * 2;
}
Enqueue(item);
}
Capacity = Count;
}
