public void SetCapacity(ArrayList list, int newCapacity) { if (newCapacity < list.Count) { throw new ArgumentOutOfRangeException(nameof(newCapacity), "ArgumentOutOfRange_SmallCapacity"); } Contract.Ensures(list.Capacity >= 0); Contract.EndContractBlock(); // We don't want to update the version number when we change the capacity. // Some existing applications have dependency on this. if (newCapacity != list.Items.Length) { if (newCapacity > 0) { var newItems = new Object[newCapacity]; if (list.Count > 0) { Array.Copy(list.Items, 0, newItems, 0, list.Count); } list.Items = newItems; } else { list.Items = new Object[_defaultCapacity]; } } }
// Contains returns true if the specified element is in the ArrayList. // It does a linear, O(n) search. Equality is determined by calling // item.Equals(). // public virtual bool Contains(ArrayList list, Object item) { if (item == null) { for (var i = 0; i < list.Count; i++) { if (list.Items[i] == null) { return(true); } } return(false); } else { for (var i = 0; i < list.Count; i++) { if ((list.Items[i] != null) && (list.Items[i].Equals(item))) { return(true); } } return(false); } }
/// <summary> /// Constructs a ArrayList. 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> /// <returns></returns> public ArrayList Create() { var list = new ArrayList { Items = emptyArray }; return(list); }
// Copies this ArrayList into array, which must be of a // compatible array type. // public virtual void CopyTo(ArrayList list, Array array, int arrayIndex) { if ((array != null) && (array.Rank != 1)) { throw new ArgumentException("Arg_RankMultiDimNotSupported"); } Contract.EndContractBlock(); // Delegate rest of error checking to Array.Copy. Array.Copy(list.Items, 0, array, arrayIndex, list.Count); }
// Clears the contents of ArrayList. public virtual void Clear(ArrayList 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++; }
// Adds the given object to the end of this list. The size of the list is // increased by one. If required, the capacity of the list is doubled // before adding the new element. // public virtual int Add(ArrayList list, Object value) { Contract.Ensures(Contract.Result <int>() >= 0); if (list.Count == list.Items.Length) { EnsureCapacity(list, list.Count + 1); } list.Items[list.Count] = value; list.Version++; return(list.Count++); }
// Clones this ArrayList, doing a shallow copy. (A copy is made of all // Object references in the ArrayList, but the Objects pointed to // are not cloned). public virtual Object Clone(ArrayList list) { Contract.Ensures(Contract.Result <Object>() != null); var la = Create(list.Count); la.Count = list.Count; la.Version = list.Version; Array.Copy(list.Items, 0, la.Items, 0, list.Count); return(la); }
public virtual Object GetValue(ArrayList list, int index) { if (index < 0 || index >= list.Count) { throw new ArgumentOutOfRangeException(nameof(index), "ArgumentOutOfRange_Index"); } Contract.EndContractBlock(); return(list.Items[index]); }
// Removes the element at the given index. The size of the list is // decreased by one. // public virtual void Remove(ArrayList list, Object obj) { Contract.Ensures(list.Count >= 0); var index = IndexOf(list, obj); if (index >= 0) { RemoveAt(list, index); } }
// Returns a read-only IList wrapper for the given IList. public List_I ReadOnly(ArrayList list) { if (list == null) { throw new ArgumentNullException(nameof(list)); } Contract.Ensures(Contract.Result <IList>() != null); Contract.EndContractBlock(); return(new ReadOnlyList <object>(list.Items)); }
public virtual void SetValue(ArrayList list, int index, object newValue) { if (index < 0 || index >= list.Count) { throw new ArgumentOutOfRangeException(nameof(index), "ArgumentOutOfRange_Index"); } Contract.EndContractBlock(); list.Items[index] = newValue; list.Version++; }
// ToArray returns a new array of a particular type containing the contents // of the ArrayList. This requires copying the ArrayList and potentially // downcasting all elements. This copy may fail and is an O(n) operation. // Internally, this implementation calls Array.Copy. // public virtual Array ToArray(ArrayList list, Type type) { if (type == null) { throw new ArgumentNullException(nameof(type)); } Contract.Ensures(Contract.Result <Array>() != null); Contract.EndContractBlock(); var array = Array.CreateInstance(type, list.Count); Array.Copy(list.Items, 0, array, 0, list.Count); return(array); }
// Ensures that the capacity of this list is at least the given minimum // value. If the currect capacity of the list is less than min, the // capacity is increased to twice the current capacity or to min, // whichever is larger. public void EnsureCapacity(ArrayList list, int min) { if (list.Items.Length < min) { var newCapacity = list.Items.Length == 0 ? _defaultCapacity : list.Items.Length * 2; // Allow the list to grow to maximum possible capacity (~2G elements) before encountering overflow. // Note that this check works even when list.Items.Length overflowed thanks to the (uint) cast if ((uint)newCapacity > XBase.Api.Arrays.MaxArrayLength) { newCapacity = XBase.Api.Arrays.MaxArrayLength; } if (newCapacity < min) { newCapacity = min; } list.Capacity = newCapacity; } }
// Constructs a ArrayList with a given initial capacity. The list is // initially empty, but will have room for the given number of elements // before any reallocations are required. // public ArrayList Create(int capacity) { var list = new ArrayList(); if (capacity < 0) { throw new ArgumentOutOfRangeException(nameof(capacity), "ArgumentOutOfRange_MustBeNonNegNum", nameof(capacity)); } Contract.EndContractBlock(); if (capacity == 0) { list.Items = emptyArray; } else { list.Items = new Object[capacity]; } return(list); }
// Inserts an element into this list at a given index. The size of the list // is increased by one. If required, the capacity of the list is doubled // before inserting the new element. // public virtual void Insert(ArrayList list, int index, Object value) { // Note that insertions at the end are legal. if (index < 0 || index > list.Count) { throw new ArgumentOutOfRangeException(nameof(index), "ArgumentOutOfRange_ArrayListInsert"); } //Contract.Ensures(Count == Contract.OldValue(Count) + 1); Contract.EndContractBlock(); if (list.Count == list.Items.Length) { EnsureCapacity(list, list.Count + 1); } if (index < list.Count) { Array.Copy(list.Items, index, list.Items, index + 1, list.Count - index); } list.Items[index] = value; list.Count++; list.Version++; }
// Removes the element at the given index. The size of the list is // decreased by one. // public virtual void RemoveAt(ArrayList list, int index) { if (index < 0 || index >= list.Count) { throw new ArgumentOutOfRangeException(nameof(index), "ArgumentOutOfRange_Index"); } Contract.Ensures(list.Count >= 0); //Contract.Ensures(Count == Contract.OldValue(Count) - 1); Contract.EndContractBlock(); list.Count--; if (index < list.Count) { Array.Copy(list.Items, index + 1, list.Items, index, list.Count - index); } list.Items[list.Count] = null; list.Version++; }
// Copies this ArrayList into array, which must be of a // compatible array type. // public static void CopyTo(this ArrayList list, Array array, int arrayIndex) { XArrayList.Api.CopyTo(list, array, arrayIndex); }
// Returns an enumerator for this list with the given // permission for removal of elements. If modifications made to the list // while an enumeration is in progress, the MoveNext and // GetObject methods of the enumerator will throw an exception. // public static IEnumerator GetEnumerator(this ArrayList list) { return(XArrayList.Api.GetEnumerator(list)); }
// Returns the index of the first occurrence of a given value in a range of // this list. The list is searched forwards from beginning to end. // 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 static int IndexOf(this ArrayList list, Object value) { return(XArrayList.Api.IndexOf(list, value)); }
public static void SetCapacity(this ArrayList list, int newCapacity) { XArrayList.Api.SetCapacity(list, newCapacity); }
// Inserts an element into this list at a given index. The size of the list // is increased by one. If required, the capacity of the list is doubled // before inserting the new element. // public static void Insert(this ArrayList list, int index, Object value) { XArrayList.Api.Insert(list, index, value); }
// Contains returns true if the specified element is in the ArrayList. // It does a linear, O(n) search. Equality is determined by calling // item.Equals(). // public static bool Contains(this ArrayList list, Object item) { return(XArrayList.Api.Contains(list, item)); }
// Clones this ArrayList, doing a shallow copy. (A copy is made of all // Object references in the ArrayList, but the Objects pointed to // are not cloned). public static Object Clone(this ArrayList list) { return(XArrayList.Api.Clone(list)); }
public static void SetValue(this ArrayList list, int index, object newValue) { XArrayList.Api.SetValue(list, index, newValue); }
//// Adds the elements of the given collection to the end of this list. If //// required, the capacity of the list is increased to twice the previous //// capacity or the new size, whichever is larger. //// //public static void AddRange(this ArrayList list, Collection_I c) //{ // XCollections.ArrayLists.AddRange(list, c); //} // Clears the contents of ArrayList. public static void Clear(this ArrayList list) { XArrayList.Api.Clear(list); }
// Ensures that the capacity of this list is at least the given minimum // value. If the currect capacity of the list is less than min, the // capacity is increased to twice the current capacity or to min, // whichever is larger. public static void EnsureCapacity(this ArrayList list, int min) { XArrayList.Api.EnsureCapacity(list, min); }
// Returns the index of the first occurrence of a given value in a range of // this list. The list is searched forwards from beginning to end. // 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 virtual int IndexOf(ArrayList list, Object value) { Contract.Ensures(Contract.Result <int>() < list.Count); return(Array.IndexOf((Array)list.Items, value, 0, list.Count)); }
public static Object GetValue(this ArrayList list, int index) { return(XArrayList.Api.GetValue(list, index)); }
// Returns an enumerator for this list with the given // permission for removal of elements. If modifications made to the list // while an enumeration is in progress, the MoveNext and // GetObject methods of the enumerator will throw an exception. // public virtual IEnumerator GetEnumerator(ArrayList list) { Contract.Ensures(Contract.Result <IEnumerator>() != null); return(new ArrayListEnumeratorSimple(list)); }
// Adds the given object to the end of this list. The size of the list is // increased by one. If required, the capacity of the list is doubled // before adding the new element. // public static int Add(this ArrayList list, Object value) { return(XArrayList.Api.Add(list, value)); }