// Removes a range of elements from this list. // public void RemoveRange <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index, int count) { if (index < 0) { throw XExceptions.Argument.OutOfRange.NeedNonNegativeNumber(nameof(index)); } if (count < 0) { throw XExceptions.Argument.OutOfRange.Count(nameof(count)); } if (list.Count - index < count) { throw XExceptions.Argument.InvalidOffsetLength(nameof(index)); } Contract.EndContractBlock(); if (count <= 0) { return; } list.Count -= count; if (index < list.Count) { Array.Copy(list.Items, index + count, list.Items, index, list.Count - index); } Array.Clear(list.Items, list.Count, count); list.Version++; }
public int FindIndex <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int startIndex, int count, Predicate <T> match) { if ((uint)startIndex > (uint)list.Count) { throw XExceptions.Argument.OutOfRange.Index(nameof(startIndex)); } if (count < 0 || startIndex > list.Count - count) { throw XExceptions.Argument.OutOfRange.Count(nameof(count)); } if (match == null) { throw XExceptions.Argument.IsNull(nameof(match)); } Contract.Ensures(Contract.Result <int>() >= -1); Contract.Ensures(Contract.Result <int>() < startIndex + count); Contract.EndContractBlock(); var endIndex = startIndex + count; for (var i = startIndex; i < endIndex; i++) { if (match(list.Items[i])) { return(i); } } return(-1); }
public Root.Code.Models.E01D.Core.Collections.Generic.List <T> GetRange <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index, int count) { if (index < 0) { throw XExceptions.Argument.OutOfRange.NeedNonNegativeNumber(nameof(index)); } if (count < 0) { throw XExceptions.Argument.OutOfRange.Count(nameof(count)); } if (list.Count - index < count) { throw XExceptions.Argument.InvalidOffsetLength(nameof(index)); } Contract.Ensures(Contract.Result <Root.Code.Models.E01D.Core.Collections.Generic.List <T> >() != null); Contract.EndContractBlock(); var newList = Create <T>(count); Array.Copy(list.Items, index, newList.Items, 0, count); newList.Count = count; return(list); }
// Constructs a List, copying the contents of the given collection. The // size and capacity of the new list will both be equal to the size of the // given collection. // public Root.Code.Models.E01D.Core.Collections.Generic.List <T> Create <T>(IEnumerable <T> collection) { if (collection == null) { throw XExceptions.Argument.IsNull(nameof(collection)); } var list = new Root.Code.Models.E01D.Core.Collections.Generic.List <T>(); var c = collection as Collection_I <T>; if (c != null && c.Count == 0) { list.Items = EmptyArray <T> .Value; } else { list.Count = 0; list.Items = EmptyArray <T> .Value; AddEnumerable(list, collection); } return(list); }
// Returns the index of the last occurrence of a given value in a range of // this list. The list is searched backwards, starting at index // index and upto count elements. The elements of // the list are compared to the given value using the Object.Equals // method. // // This method uses the Array.LastIndexOf method to perform the // search. // public int LastIndexOf <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, T item, int index, int count) { if ((list.Count != 0) && (index < 0)) { throw XExceptions.Argument.OutOfRange.NeedNonNegativeNumber(nameof(index)); } if ((list.Count != 0) && (count < 0)) { throw XExceptions.Argument.OutOfRange.Count(nameof(count)); } if (list.Count == 0) { // Special case for empty list return(-1); } if (index >= list.Count) { throw XExceptions.Argument.OutOfRange.BiggerThanCollection(nameof(index)); } if (count > index + 1) { throw XExceptions.Argument.OutOfRange.BiggerThanCollection(nameof(index)); } return(Array.LastIndexOf(list.Items, item, index, count)); }
public void SetCapacity <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int newCapacity) { if (newCapacity < list.Count) { throw XExceptions.Argument.OutOfRange.SmallCapacity(nameof(newCapacity)); } Contract.EndContractBlock(); if (newCapacity != list.Items.Length) { if (newCapacity > 0) { var newItems = new T[newCapacity]; if (list.Count > 0) { Array.Copy(list.Items, 0L, newItems, 0, list.Count); } list.Items = newItems; } else { list.Items = EmptyArray <T> .Value; } } }
// Sorts the elements in a section of this list. The sort compares the // elements to each other using the given IComparer interface. If // comparer is null, the elements are compared to each other using // the IComparable interface, which in that case must be implemented by all // elements of the list. // // This method uses the Array.Sort method to sort the elements. // public void Sort <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index, int count, IComparer <T> comparer) { if (index < 0) { throw XExceptions.Argument.OutOfRange.NeedNonNegativeNumber(nameof(index)); } if (count < 0) { throw XExceptions.Argument.OutOfRange.Count(nameof(count)); } if (list.Count - index < count) { throw XExceptions.Argument.InvalidOffsetLength(nameof(count)); } Contract.EndContractBlock(); if (count > 1) { Array.Sort(list.Items, index, count, comparer); } list.Version++; }
// Inserts the elements of the given collection at a given index. If // required, the capacity of the list is increased to twice the previous // capacity or the new size, whichever is larger. Ranges may be added // to the end of the list by setting index to the List's size. // public void InsertRange <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index, IEnumerable <T> collection) { if (collection == null) { throw XExceptions.Argument.IsNull(nameof(collection)); } if ((uint)index > (uint)list.Count) { throw XExceptions.Argument.OutOfRange.Index(nameof(index)); } Contract.EndContractBlock(); var c = collection as Collection_I <T>; if (c != null) { // if collection is ICollection<T> var count = c.Count; if (count > 0) { EnsureCapacity(list, list.Count + count); if (index < list.Count) { Array.Copy(list.Items, index, list.Items, index + count, list.Count - index); } // If we're inserting a List into itself, we want to be able to deal with that. if (list == c) { // Copy first part of list.Items to insert location Array.Copy(list.Items, 0, list.Items, index, index); // Copy last part of list.Items back to inserted location Array.Copy(list.Items, index + count, list.Items, index * 2, list.Count - index); } else { c.CopyTo(list.Items, index); } list.Count += count; } } else if (index < list.Count) { // We're inserting a lazy enumerable. Call Insert on each of the constituent items. using (var en = collection.GetEnumerator()) { while (en.MoveNext()) { Insert(list, index++, en.Current); } } } else { // We're adding a lazy enumerable because the index is at the end of this list. AddEnumerable(list, collection); } list.Version++; }
public Root.Code.Models.E01D.Core.Collections.Generic.List <T> Copy <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list) { var newList = Create <T>(); list.Iterate(x => newList.Add(x)); return(newList); }
public void Add <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, T item) { if (list.Count == list.Items.Length) { EnsureCapacity(list, list.Count + 1); } list.Items[list.Count++] = item; list.Version++; }
/// <summary> /// Creates a new List. The list is initially empty and has a capacity /// of zero. Upon adding the first element to the list the capacity is /// increased to _defaultCapacity, and then increased in multiples of two /// as required. /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public Root.Code.Models.E01D.Core.Collections.Generic.List <T> Create <T>() { var list = new Root.Code.Models.E01D.Core.Collections.Generic.List <T>() { Items = EmptyArray <T> .Value }; return(list); }
// Returns the index of the last occurrence of a given value in a range of // this list. The list is searched backwards, starting at index // index and ending at the first element in the list. The // elements of the list are compared to the given value using the // Object.Equals method. // // This method uses the Array.LastIndexOf method to perform the // search. // public int LastIndexOf <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, T item, int index) { if (index >= list.Count) { throw XExceptions.Argument.OutOfRange.Index(nameof(index)); } return(LastIndexOf(list, item, index, index + 1)); }
// Sets the capacity of this list to the size of the list. This method can // be used to minimize a list's memory overhead once it is known that no // new elements will be added to the list. To completely clear a list and // release all memory referenced by the list, execute the following // statements: // // list.Clear(); // list.TrimExcess(); // public void TrimExcess <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list) { var threshold = (int)(((double)list.Items.Length) * 0.9); if (list.Count < threshold) { SetCapacity(list, list.Count); } }
public void Iterate <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, Action <T> action) { for (var i = 0; i < list.Count; i++) { var item = list.GetItem(i); action(item); } }
// Clears the contents of List. public void Clear <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list) { if (list.Count > 0) { Array.Clear(list.Items, 0, list.Count); // Don't need to doc this but we clear the elements so that the gc can reclaim the references. list.Count = 0; } list.Version++; }
// Returns the index of the last occurrence of a given value in a range of // this list. The list is searched backwards, starting at the end // and ending at the first element in the list. The elements of the list // are compared to the given value using the Object.Equals method. // // This method uses the Array.LastIndexOf method to perform the // search. // public int LastIndexOf <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, T item) { if (list.Count == 0) { // Special case for empty list return(-1); } else { return(LastIndexOf(list, item, list.Count - 1, list.Count)); } }
// Contains returns true if the specified element is in the List. // It does a linear, O(n) search. Equality is determined by calling // EqualityComparer<T>.Default.Equals(). public bool Contains <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, T item) { // PERF: IndexOf calls Array.IndexOf, which internally // calls EqualityComparer<T>.Default.IndexOf, which // is specialized for different types. This // boosts performance since instead of making a // virtual method call each iteration of the loop, // via EqualityComparer<T>.Default.Equals, we // only make one virtual call to EqualityComparer.IndexOf. return(list.Count != 0 && IndexOf(list, item) != -1); }
// Copies a section of this list to the given array at the given index. // // The method uses the Array.Copy method to copy the elements. // public void CopyTo <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index, T[] array, int arrayIndex, int count) { if (list.Count - index < count) { XExceptions.Argument.InvalidOffsetLength(nameof(index)); } Contract.EndContractBlock(); // Delegate rest of error checking to Array.Copy. Array.Copy(list.Items, index, array, arrayIndex, count); }
public void SetItem <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index, T item) { if ((uint)index >= (uint)list.Count) { throw XExceptions.Argument.OutOfRange.Index(nameof(index)); } Contract.EndContractBlock(); list.Items[index] = item; list.Version++; }
// Removes the element at the given index. The size of the list is // decreased by one. // public bool Remove <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, T item) { var index = IndexOf(list, item); if (index >= 0) { RemoveAt(list, index); return(true); } return(false); }
// ToArray returns an array containing the contents of the List. // This requires copying the List, which is an O(n) operation. public T[] ToArray <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list) { if (list.Count == 0) { return(EmptyArray <T> .Value); } var array = new T[list.Count]; Array.Copy(list.Items, 0, array, 0, list.Count); return(array); }
public void Sort <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, Comparison <T> comparison) { if (comparison == null) { throw XExceptions.Argument.IsNull(nameof(comparison)); } Contract.EndContractBlock(); if (list.Count > 1) { XCollections.Sorting.Sort(list.Items, 0, list.Count, comparison); } list.Version++; }
// Returns the index of the first occurrence of a given value in a range of // this list. The list is searched forwards, starting at index // index and upto count number of elements. The // elements of the list are compared to the given value using the // Object.Equals method. // // This method uses the Array.IndexOf method to perform the // search. // public int IndexOf <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, T item, int index, int count) { if (index > list.Count) { throw XExceptions.Argument.OutOfRange.Index(nameof(index)); } if (count < 0 || index > list.Count - count) { throw XExceptions.Argument.OutOfRange.Count(nameof(count)); } return(Array.IndexOf(list.Items, item, index, count)); }
// Removes the element at the given index. The size of the list is // decreased by one. // public void RemoveAt <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index) { if ((uint)index >= (uint)list.Count) { throw XExceptions.Argument.OutOfRange.Index(nameof(index)); } Contract.EndContractBlock(); list.Count--; if (index < list.Count) { Array.Copy(list.Items, index + 1, list.Items, index, list.Count - index); } list.Items[list.Count] = default(T); list.Version++; }
public bool TrueForAll <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, Predicate <T> match) { if (match == null) { throw XExceptions.Argument.IsNull(nameof(match)); } Contract.EndContractBlock(); for (var i = 0; i < list.Count; i++) { if (!match(list.Items[i])) { return(false); } } return(true); }
public T FindLast <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, Predicate <T> match) { if (match == null) { throw XExceptions.Argument.IsNull(nameof(match)); } Contract.EndContractBlock(); for (var i = list.Count - 1; i >= 0; i--) { if (match(list.Items[i])) { return(list.Items[i]); } } return(default(T)); }
public TOut Iterate <T, TOut>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, FuncOut <T, TOut, bool> action) { TOut result = default(TOut); for (var i = 0; i < list.Count; i++) { var item = list.GetItem(i); if (action(item, out result)) { return(result); } ; } return(result); }
public int FindLastIndex <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int startIndex, int count, Predicate <T> match) { if (match == null) { throw XExceptions.Argument.IsNull(nameof(match)); } Contract.Ensures(Contract.Result <int>() >= -1); Contract.Ensures(Contract.Result <int>() <= startIndex); Contract.EndContractBlock(); if (list.Count == 0) { // Special case for 0 length List if (startIndex != -1) { throw XExceptions.Argument.OutOfRange.Index(nameof(startIndex)); } } else { // Make sure we're not out of range if ((uint)startIndex >= (uint)list.Count) { throw XExceptions.Argument.OutOfRange.Index(nameof(startIndex)); } } // 2nd have of this also catches when startIndex == MAXINT, so MAXINT - 0 + 1 == -1, which is < 0. if (count < 0 || startIndex - count + 1 < 0) { throw XExceptions.Argument.OutOfRange.Count(nameof(startIndex)); } var endIndex = startIndex - count; for (var i = startIndex; i > endIndex; i--) { if (match(list.Items[i])) { return(i); } } return(-1); }
public Root.Code.Models.E01D.Core.Collections.Generic.List <T> FindAll <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, Predicate <T> match) { if (match == null) { throw XExceptions.Argument.IsNull(nameof(match)); } var newList = new Root.Code.Models.E01D.Core.Collections.Generic.List <T>(); for (var i = 0; i < list.Count; i++) { if (match(list.Items[i])) { newList.Add(list.Items[i]); } } return(newList); }
// Searches a section of the list for a given element using a binary search // algorithm. Elements of the list are compared to the search value using // the given IComparer interface. If comparer is null, elements of // the list are compared to the search value using the IComparable // interface, which in that case must be implemented by all elements of the // list and the given search value. This method assumes that the given // section of the list is already sorted; if this is not the case, the // result will be incorrect. // // The method returns the index of the given value in the list. If the // list does not contain the given value, the method returns a negative // integer. The bitwise complement operator (~) can be applied to a // negative result to produce the index of the first element (if any) that // is larger than the given search value. This is also the index at which // the search value should be inserted into the list in order for the list // to remain sorted. // // The method uses the Array.BinarySearch method to perform the // search. // public int BinarySearch <T>(Root.Code.Models.E01D.Core.Collections.Generic.List <T> list, int index, int count, T item, IComparer <T> comparer) { if (index < 0) { throw XExceptions.Argument.OutOfRange.NeedNonNegativeNumber(nameof(index)); } if (count < 0) { throw XExceptions.Argument.OutOfRange.NeedNonNegativeNumber(nameof(count)); } if (list.Count - index < count) { throw XExceptions.Argument.InvalidOffsetLength(nameof(count)); } return(Array.BinarySearch(list.Items, index, count, item, comparer)); }