using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
namespace System.Collections
{
/// Implements the
/// 1
// Token: 0x02000113 RID: 275
[DebuggerDisplay("Count={Count}")]
[DebuggerTypeProxy(typeof(CollectionDebuggerView))]
[ComVisible(true)]
[Serializable]
public class ArrayList : IEnumerable, ICloneable, ICollection, IList
{
/// Initializes a new instance of the
// Token: 0x06000DB9 RID: 3513 RVA: 0x0003BB44 File Offset: 0x00039D44
public ArrayList()
{
this._items = ArrayList.EmptyArray;
}
/// Initializes a new instance of the
///
///
// Token: 0x06000DBA RID: 3514 RVA: 0x0003BB58 File Offset: 0x00039D58
public ArrayList(ICollection c)
{
if (c == null)
{
throw new ArgumentNullException("c");
}
Array array = c as Array;
if (array != null && array.Rank != 1)
{
throw new RankException();
}
this._items = new object[c.Count];
this.AddRange(c);
}
/// Initializes a new instance of the
///
///
// Token: 0x06000DBB RID: 3515 RVA: 0x0003BBB4 File Offset: 0x00039DB4
public ArrayList(int capacity)
{
if (capacity < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("capacity", capacity, "The initial capacity can't be smaller than zero.");
}
if (capacity == 0)
{
capacity = 4;
}
this._items = new object[capacity];
}
// Token: 0x06000DBC RID: 3516 RVA: 0x0003BBF0 File Offset: 0x00039DF0
private ArrayList(int initialCapacity, bool forceZeroSize)
{
if (forceZeroSize)
{
this._items = null;
return;
}
throw new InvalidOperationException("Use ArrayList(int)");
}
// Token: 0x06000DBD RID: 3517 RVA: 0x0003BC18 File Offset: 0x00039E18
private ArrayList(object[] array, int index, int count)
{
if (count == 0)
{
this._items = new object[4];
}
else
{
this._items = new object[count];
}
Array.Copy(array, index, this._items, 0, count);
this._size = count;
}
/// Gets or sets the element at the specified index.
/// The element at the specified index.
///
///
/// 1
// Token: 0x17000215 RID: 533
public virtual object this[int index]
{
get
{
if (index < 0 || index >= this._size)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index is less than 0 or more than or equal to the list count.");
}
return this._items[index];
}
set
{
if (index < 0 || index >= this._size)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index is less than 0 or more than or equal to the list count.");
}
this._items[index] = value;
this._version++;
}
}
/// Gets the number of elements actually contained in the
/// The number of elements actually contained in the
/// 1
// Token: 0x17000216 RID: 534
// (get) Token: 0x06000DC1 RID: 3521 RVA: 0x0003BD00 File Offset: 0x00039F00
public virtual int Count
{
get
{
return this._size;
}
}
/// Gets or sets the number of elements that the
/// The number of elements that the
///
///
/// There is not enough memory available on the system.
/// 1
// Token: 0x17000217 RID: 535
// (get) Token: 0x06000DC2 RID: 3522 RVA: 0x0003BD08 File Offset: 0x00039F08
// (set) Token: 0x06000DC3 RID: 3523 RVA: 0x0003BD14 File Offset: 0x00039F14
public virtual int Capacity
{
get
{
return this._items.Length;
}
set
{
if (value < this._size)
{
ArrayList.ThrowNewArgumentOutOfRangeException("Capacity", value, "Must be more than count.");
}
object[] array = new object[value];
Array.Copy(this._items, 0, array, 0, this._size);
this._items = array;
}
}
/// Gets a value indicating whether the
/// true if the
/// 2
// Token: 0x17000218 RID: 536
// (get) Token: 0x06000DC4 RID: 3524 RVA: 0x0003BD64 File Offset: 0x00039F64
public virtual bool IsFixedSize
{
get
{
return false;
}
}
/// Gets a value indicating whether the
/// true if the
/// 2
// Token: 0x17000219 RID: 537
// (get) Token: 0x06000DC5 RID: 3525 RVA: 0x0003BD68 File Offset: 0x00039F68
public virtual bool IsReadOnly
{
get
{
return false;
}
}
/// Gets a value indicating whether access to the
/// true if access to the
/// 2
// Token: 0x1700021A RID: 538
// (get) Token: 0x06000DC6 RID: 3526 RVA: 0x0003BD6C File Offset: 0x00039F6C
public virtual bool IsSynchronized
{
get
{
return false;
}
}
/// Gets an object that can be used to synchronize access to the
/// An object that can be used to synchronize access to the
/// 2
// Token: 0x1700021B RID: 539
// (get) Token: 0x06000DC7 RID: 3527 RVA: 0x0003BD70 File Offset: 0x00039F70
public virtual object SyncRoot
{
get
{
return this;
}
}
// Token: 0x06000DC8 RID: 3528 RVA: 0x0003BD74 File Offset: 0x00039F74
private void EnsureCapacity(int count)
{
if (count <= this._items.Length)
{
return;
}
int i = this._items.Length << 1;
if (i == 0)
{
i = 4;
}
while (i < count)
{
i <<= 1;
}
object[] array = new object[i];
Array.Copy(this._items, 0, array, 0, this._items.Length);
this._items = array;
}
// Token: 0x06000DC9 RID: 3529 RVA: 0x0003BDD8 File Offset: 0x00039FD8
private void Shift(int index, int count)
{
if (count > 0)
{
if (this._size + count > this._items.Length)
{
int i;
for (i = ((this._items.Length <= 0) ? 1 : (this._items.Length << 1)); i < this._size + count; i <<= 1)
{
}
object[] array = new object[i];
Array.Copy(this._items, 0, array, 0, index);
Array.Copy(this._items, index, array, index + count, this._size - index);
this._items = array;
}
else
{
Array.Copy(this._items, index, this._items, index + count, this._size - index);
}
}
else if (count < 0)
{
int num = index - count;
Array.Copy(this._items, num, this._items, index, this._size - num);
Array.Clear(this._items, this._size + count, -count);
}
}
/// Adds an object to the end of the
/// The
/// The
/// 1
// Token: 0x06000DCA RID: 3530 RVA: 0x0003BED0 File Offset: 0x0003A0D0
public virtual int Add(object value)
{
if (this._items.Length <= this._size)
{
this.EnsureCapacity(this._size + 1);
}
this._items[this._size] = value;
this._version++;
return this._size++;
}
/// Removes all elements from the
/// The
/// 1
// Token: 0x06000DCB RID: 3531 RVA: 0x0003BF2C File Offset: 0x0003A12C
public virtual void Clear()
{
Array.Clear(this._items, 0, this._size);
this._size = 0;
this._version++;
}
/// Determines whether an element is in the
/// true if
/// 1
// Token: 0x06000DCC RID: 3532 RVA: 0x0003BF58 File Offset: 0x0003A158
public virtual bool Contains(object item)
{
return this.IndexOf(item, 0, this._size) > -1;
}
// Token: 0x06000DCD RID: 3533 RVA: 0x0003BF6C File Offset: 0x0003A16C
internal virtual bool Contains(object value, int startIndex, int count)
{
return this.IndexOf(value, startIndex, count) > -1;
}
/// Searches for the specified
/// The zero-based index of the first occurrence of
/// 1
// Token: 0x06000DCE RID: 3534 RVA: 0x0003BF7C File Offset: 0x0003A17C
public virtual int IndexOf(object value)
{
return this.IndexOf(value, 0);
}
/// Searches for the specified
/// The zero-based index of the first occurrence of
///
///
/// 1
// Token: 0x06000DCF RID: 3535 RVA: 0x0003BF88 File Offset: 0x0003A188
public virtual int IndexOf(object value, int startIndex)
{
return this.IndexOf(value, startIndex, this._size - startIndex);
}
/// Searches for the specified
/// The zero-based index of the first occurrence of
///
///
/// 1
// Token: 0x06000DD0 RID: 3536 RVA: 0x0003BF9C File Offset: 0x0003A19C
public virtual int IndexOf(object value, int startIndex, int count)
{
if (startIndex < 0 || startIndex > this._size)
{
ArrayList.ThrowNewArgumentOutOfRangeException("startIndex", startIndex, "Does not specify valid index.");
}
if (count < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("count", count, "Can't be less than 0.");
}
if (startIndex > this._size - count)
{
throw new ArgumentOutOfRangeException("count", "Start index and count do not specify a valid range.");
}
return Array.IndexOf(this._items, value, startIndex, count);
}
/// Searches for the specified
/// The zero-based index of the last occurrence of
/// 2
// Token: 0x06000DD1 RID: 3537 RVA: 0x0003C01C File Offset: 0x0003A21C
public virtual int LastIndexOf(object value)
{
return this.LastIndexOf(value, this._size - 1);
}
/// Searches for the specified
/// The zero-based index of the last occurrence of
///
///
/// 2
// Token: 0x06000DD2 RID: 3538 RVA: 0x0003C030 File Offset: 0x0003A230
public virtual int LastIndexOf(object value, int startIndex)
{
return this.LastIndexOf(value, startIndex, startIndex + 1);
}
/// Searches for the specified
/// The zero-based index of the last occurrence of
///
///
/// 2
// Token: 0x06000DD3 RID: 3539 RVA: 0x0003C040 File Offset: 0x0003A240
public virtual int LastIndexOf(object value, int startIndex, int count)
{
return Array.LastIndexOf(this._items, value, startIndex, count);
}
/// Inserts an element into the
///
///
/// The
/// 1
// Token: 0x06000DD4 RID: 3540 RVA: 0x0003C050 File Offset: 0x0003A250
public virtual void Insert(int index, object value)
{
if (index < 0 || index > this._size)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index must be >= 0 and <= Count.");
}
this.Shift(index, 1);
this._items[index] = value;
this._size++;
this._version++;
}
/// Inserts the elements of a collection into the
///
///
///
///
/// The
/// 2
// Token: 0x06000DD5 RID: 3541 RVA: 0x0003C0B4 File Offset: 0x0003A2B4
public virtual void InsertRange(int index, ICollection c)
{
if (c == null)
{
throw new ArgumentNullException("c");
}
if (index < 0 || index > this._size)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index must be >= 0 and <= Count.");
}
int count = c.Count;
if (this._items.Length < this._size + count)
{
this.EnsureCapacity(this._size + count);
}
if (index < this._size)
{
Array.Copy(this._items, index, this._items, index + count, this._size - index);
}
if (this == c.SyncRoot)
{
Array.Copy(this._items, 0, this._items, index, index);
Array.Copy(this._items, index + count, this._items, index << 1, this._size - index);
}
else
{
c.CopyTo(this._items, index);
}
this._size += c.Count;
this._version++;
}
/// Removes the first occurrence of a specific object from the
/// The
/// 1
// Token: 0x06000DD6 RID: 3542 RVA: 0x0003C1C0 File Offset: 0x0003A3C0
public virtual void Remove(object obj)
{
int num = this.IndexOf(obj);
if (num > -1)
{
this.RemoveAt(num);
}
this._version++;
}
/// Removes the element at the specified index of the
///
///
/// The
/// 1
// Token: 0x06000DD7 RID: 3543 RVA: 0x0003C1F4 File Offset: 0x0003A3F4
public virtual void RemoveAt(int index)
{
if (index < 0 || index >= this._size)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Less than 0 or more than list count.");
}
this.Shift(index, -1);
this._size--;
this._version++;
}
/// Removes a range of elements from the
///
///
///
///
/// The
/// 2
// Token: 0x06000DD8 RID: 3544 RVA: 0x0003C250 File Offset: 0x0003A450
public virtual void RemoveRange(int index, int count)
{
ArrayList.CheckRange(index, count, this._size);
this.Shift(index, -count);
this._size -= count;
this._version++;
}
/// Reverses the order of the elements in the entire
/// The
/// 2
// Token: 0x06000DD9 RID: 3545 RVA: 0x0003C290 File Offset: 0x0003A490
public virtual void Reverse()
{
Array.Reverse(this._items, 0, this._size);
this._version++;
}
/// Reverses the order of the elements in the specified range.
///
///
///
///
/// The
/// 2
// Token: 0x06000DDA RID: 3546 RVA: 0x0003C2C0 File Offset: 0x0003A4C0
public virtual void Reverse(int index, int count)
{
ArrayList.CheckRange(index, count, this._size);
Array.Reverse(this._items, index, count);
this._version++;
}
/// Copies the entire
///
///
///
///
/// The type of the source
/// 2
// Token: 0x06000DDB RID: 3547 RVA: 0x0003C2F8 File Offset: 0x0003A4F8
public virtual void CopyTo(Array array)
{
Array.Copy(this._items, array, this._size);
}
/// Copies the entire
///
///
///
///
///
///
/// The type of the source
/// 2
// Token: 0x06000DDC RID: 3548 RVA: 0x0003C30C File Offset: 0x0003A50C
public virtual void CopyTo(Array array, int arrayIndex)
{
this.CopyTo(0, array, arrayIndex, this._size);
}
/// Copies a range of elements from the
///
///
///
///
///
///
/// The type of the source
/// 2
// Token: 0x06000DDD RID: 3549 RVA: 0x0003C320 File Offset: 0x0003A520
public virtual void CopyTo(int index, Array array, int arrayIndex, int count)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
if (array.Rank != 1)
{
throw new ArgumentException("Must have only 1 dimensions.", "array");
}
Array.Copy(this._items, index, array, arrayIndex, count);
}
/// Returns an enumerator for the entire
/// An
/// 2
// Token: 0x06000DDE RID: 3550 RVA: 0x0003C360 File Offset: 0x0003A560
public virtual IEnumerator GetEnumerator()
{
return new ArrayList.SimpleEnumerator(this);
}
/// Returns an enumerator for a range of elements in the
/// An
///
///
///
///
/// 2
// Token: 0x06000DDF RID: 3551 RVA: 0x0003C368 File Offset: 0x0003A568
public virtual IEnumerator GetEnumerator(int index, int count)
{
ArrayList.CheckRange(index, count, this._size);
return new ArrayList.ArrayListEnumerator(this, index, count);
}
/// Adds the elements of an
///
///
/// The
/// 1
// Token: 0x06000DE0 RID: 3552 RVA: 0x0003C380 File Offset: 0x0003A580
public virtual void AddRange(ICollection c)
{
this.InsertRange(this._size, c);
}
/// Searches the entire sorted
/// The zero-based index of
/// Neither
///
///
/// 1
// Token: 0x06000DE1 RID: 3553 RVA: 0x0003C390 File Offset: 0x0003A590
public virtual int BinarySearch(object value)
{
int num;
try
{
num = Array.BinarySearch(this._items, 0, this._size, value);
}
catch (InvalidOperationException ex)
{
throw new ArgumentException(ex.Message);
}
return num;
}
/// Searches the entire sorted
/// The zero-based index of
///
///
///
///
/// 1
// Token: 0x06000DE2 RID: 3554 RVA: 0x0003C3EC File Offset: 0x0003A5EC
public virtual int BinarySearch(object value, IComparer comparer)
{
int num;
try
{
num = Array.BinarySearch(this._items, 0, this._size, value, comparer);
}
catch (InvalidOperationException ex)
{
throw new ArgumentException(ex.Message);
}
return num;
}
/// Searches a range of elements in the sorted
/// The zero-based index of
///
///
///
///
///
///
/// 1
// Token: 0x06000DE3 RID: 3555 RVA: 0x0003C448 File Offset: 0x0003A648
public virtual int BinarySearch(int index, int count, object value, IComparer comparer)
{
int num;
try
{
num = Array.BinarySearch(this._items, index, count, value, comparer);
}
catch (InvalidOperationException ex)
{
throw new ArgumentException(ex.Message);
}
return num;
}
/// Returns an
/// An
///
///
///
///
/// 2
// Token: 0x06000DE4 RID: 3556 RVA: 0x0003C4A0 File Offset: 0x0003A6A0
public virtual ArrayList GetRange(int index, int count)
{
ArrayList.CheckRange(index, count, this._size);
if (this.IsSynchronized)
{
return ArrayList.Synchronized(new ArrayList.RangedArrayList(this, index, count));
}
return new ArrayList.RangedArrayList(this, index, count);
}
/// Copies the elements of a collection over a range of elements in the
///
///
///
///
/// The
/// 2
// Token: 0x06000DE5 RID: 3557 RVA: 0x0003C4DC File Offset: 0x0003A6DC
public virtual void SetRange(int index, ICollection c)
{
if (c == null)
{
throw new ArgumentNullException("c");
}
if (index < 0 || index + c.Count > this._size)
{
throw new ArgumentOutOfRangeException("index");
}
c.CopyTo(this._items, index);
this._version++;
}
/// Sets the capacity to the actual number of elements in the
/// The
/// 2
// Token: 0x06000DE6 RID: 3558 RVA: 0x0003C53C File Offset: 0x0003A73C
public virtual void TrimToSize()
{
if (this._items.Length > this._size)
{
object[] array;
if (this._size == 0)
{
array = new object[4];
}
else
{
array = new object[this._size];
}
Array.Copy(this._items, 0, array, 0, this._size);
this._items = array;
}
}
/// Sorts the elements in the entire
/// The
/// 1
// Token: 0x06000DE7 RID: 3559 RVA: 0x0003C59C File Offset: 0x0003A79C
public virtual void Sort()
{
Array.Sort(this._items, 0, this._size);
this._version++;
}
/// Sorts the elements in the entire
/// The
/// 1
// Token: 0x06000DE8 RID: 3560 RVA: 0x0003C5CC File Offset: 0x0003A7CC
public virtual void Sort(IComparer comparer)
{
Array.Sort(this._items, 0, this._size, comparer);
}
/// Sorts the elements in a range of elements in
///
///
///
///
/// The
/// 1
// Token: 0x06000DE9 RID: 3561 RVA: 0x0003C5E4 File Offset: 0x0003A7E4
public virtual void Sort(int index, int count, IComparer comparer)
{
ArrayList.CheckRange(index, count, this._size);
Array.Sort(this._items, index, count, comparer);
}
/// Copies the elements of the
/// An
/// 1
// Token: 0x06000DEA RID: 3562 RVA: 0x0003C604 File Offset: 0x0003A804
public virtual object[] ToArray()
{
object[] array = new object[this._size];
this.CopyTo(array);
return array;
}
/// Copies the elements of the
/// An array of the specified element type containing copies of the elements of the
///
///
/// The type of the source
/// 1
// Token: 0x06000DEB RID: 3563 RVA: 0x0003C628 File Offset: 0x0003A828
public virtual Array ToArray(Type type)
{
Array array = Array.CreateInstance(type, this._size);
this.CopyTo(array);
return array;
}
/// Creates a shallow copy of the
/// A shallow copy of the
/// 2
// Token: 0x06000DEC RID: 3564 RVA: 0x0003C64C File Offset: 0x0003A84C
public virtual object Clone()
{
return new ArrayList(this._items, 0, this._size);
}
// Token: 0x06000DED RID: 3565 RVA: 0x0003C660 File Offset: 0x0003A860
internal static void CheckRange(int index, int count, int listCount)
{
if (index < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Can't be less than 0.");
}
if (count < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("count", count, "Can't be less than 0.");
}
if (index > listCount - count)
{
throw new ArgumentException("Index and count do not denote a valid range of elements.", "index");
}
}
// Token: 0x06000DEE RID: 3566 RVA: 0x0003C6C0 File Offset: 0x0003A8C0
internal static void ThrowNewArgumentOutOfRangeException(string name, object actual, string message)
{
throw new ArgumentOutOfRangeException(name, actual, message);
}
/// Creates an
/// The
///
///
/// 2
// Token: 0x06000DEF RID: 3567 RVA: 0x0003C6CC File Offset: 0x0003A8CC
public static ArrayList Adapter(IList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
ArrayList arrayList = list as ArrayList;
if (arrayList != null)
{
return arrayList;
}
arrayList = new ArrayList.ArrayListAdapter(list);
if (list.IsSynchronized)
{
return ArrayList.Synchronized(arrayList);
}
return arrayList;
}
/// Returns an
/// An
///
///
/// 2
// Token: 0x06000DF0 RID: 3568 RVA: 0x0003C714 File Offset: 0x0003A914
public static ArrayList Synchronized(ArrayList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (list.IsSynchronized)
{
return list;
}
return new ArrayList.SynchronizedArrayListWrapper(list);
}
/// Returns an
/// An
///
///
/// 2
// Token: 0x06000DF1 RID: 3569 RVA: 0x0003C748 File Offset: 0x0003A948
public static IList Synchronized(IList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (list.IsSynchronized)
{
return list;
}
return new ArrayList.SynchronizedListWrapper(list);
}
/// Returns a read-only
/// A read-only
///
///
/// 2
// Token: 0x06000DF2 RID: 3570 RVA: 0x0003C77C File Offset: 0x0003A97C
public static ArrayList ReadOnly(ArrayList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (list.IsReadOnly)
{
return list;
}
return new ArrayList.ReadOnlyArrayListWrapper(list);
}
/// Returns a read-only
/// A read-only
///
///
/// 2
// Token: 0x06000DF3 RID: 3571 RVA: 0x0003C7B0 File Offset: 0x0003A9B0
public static IList ReadOnly(IList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (list.IsReadOnly)
{
return list;
}
return new ArrayList.ReadOnlyListWrapper(list);
}
/// Returns an
/// An
///
///
/// 2
// Token: 0x06000DF4 RID: 3572 RVA: 0x0003C7E4 File Offset: 0x0003A9E4
public static ArrayList FixedSize(ArrayList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (list.IsFixedSize)
{
return list;
}
return new ArrayList.FixedSizeArrayListWrapper(list);
}
/// Returns an
/// An
///
///
/// 2
// Token: 0x06000DF5 RID: 3573 RVA: 0x0003C818 File Offset: 0x0003AA18
public static IList FixedSize(IList list)
{
if (list == null)
{
throw new ArgumentNullException("list");
}
if (list.IsFixedSize)
{
return list;
}
return new ArrayList.FixedSizeListWrapper(list);
}
/// Returns an
/// An
///
///
/// 2
// Token: 0x06000DF6 RID: 3574 RVA: 0x0003C84C File Offset: 0x0003AA4C
public static ArrayList Repeat(object value, int count)
{
ArrayList arrayList = new ArrayList(count);
for (int i = 0; i < count; i++)
{
arrayList.Add(value);
}
return arrayList;
}
// Token: 0x0400038D RID: 909
private const int DefaultInitialCapacity = 4;
// Token: 0x0400038E RID: 910
private int _size;
// Token: 0x0400038F RID: 911
private object[] _items;
// Token: 0x04000390 RID: 912
private int _version;
// Token: 0x04000391 RID: 913
private static readonly object[] EmptyArray = new object[0];
// Token: 0x02000114 RID: 276
private sealed class ArrayListEnumerator : IEnumerator, ICloneable
{
// Token: 0x06000DF7 RID: 3575 RVA: 0x0003C87C File Offset: 0x0003AA7C
public ArrayListEnumerator(ArrayList list)
: this(list, 0, list.Count)
{
}
// Token: 0x06000DF8 RID: 3576 RVA: 0x0003C88C File Offset: 0x0003AA8C
public ArrayListEnumerator(ArrayList list, int index, int count)
{
this.m_List = list;
this.m_Index = index;
this.m_Count = count;
this.m_Pos = this.m_Index - 1;
this.m_Current = null;
this.m_ExpectedStateChanges = list._version;
}
// Token: 0x06000DF9 RID: 3577 RVA: 0x0003C8D8 File Offset: 0x0003AAD8
public object Clone()
{
return base.MemberwiseClone();
}
// Token: 0x1700021C RID: 540
// (get) Token: 0x06000DFA RID: 3578 RVA: 0x0003C8E0 File Offset: 0x0003AAE0
public object Current
{
get
{
if (this.m_Pos == this.m_Index - 1)
{
throw new InvalidOperationException("Enumerator unusable (Reset pending, or past end of array.");
}
return this.m_Current;
}
}
// Token: 0x06000DFB RID: 3579 RVA: 0x0003C914 File Offset: 0x0003AB14
public bool MoveNext()
{
if (this.m_List._version != this.m_ExpectedStateChanges)
{
throw new InvalidOperationException("List has changed.");
}
this.m_Pos++;
if (this.m_Pos - this.m_Index < this.m_Count)
{
this.m_Current = this.m_List[this.m_Pos];
return true;
}
return false;
}
// Token: 0x06000DFC RID: 3580 RVA: 0x0003C984 File Offset: 0x0003AB84
public void Reset()
{
this.m_Current = null;
this.m_Pos = this.m_Index - 1;
}
// Token: 0x04000392 RID: 914
private int m_Pos;
// Token: 0x04000393 RID: 915
private int m_Index;
// Token: 0x04000394 RID: 916
private int m_Count;
// Token: 0x04000395 RID: 917
private object m_Current;
// Token: 0x04000396 RID: 918
private ArrayList m_List;
// Token: 0x04000397 RID: 919
private int m_ExpectedStateChanges;
}
// Token: 0x02000115 RID: 277
private sealed class SimpleEnumerator : IEnumerator, ICloneable
{
// Token: 0x06000DFD RID: 3581 RVA: 0x0003C99C File Offset: 0x0003AB9C
public SimpleEnumerator(ArrayList list)
{
this.list = list;
this.index = -1;
this.version = list._version;
this.currentElement = ArrayList.SimpleEnumerator.endFlag;
}
// Token: 0x06000DFF RID: 3583 RVA: 0x0003C9D8 File Offset: 0x0003ABD8
public object Clone()
{
return base.MemberwiseClone();
}
// Token: 0x06000E00 RID: 3584 RVA: 0x0003C9E0 File Offset: 0x0003ABE0
public bool MoveNext()
{
if (this.version != this.list._version)
{
throw new InvalidOperationException("List has changed.");
}
if (++this.index < this.list.Count)
{
this.currentElement = this.list[this.index];
return true;
}
this.currentElement = ArrayList.SimpleEnumerator.endFlag;
return false;
}
// Token: 0x1700021D RID: 541
// (get) Token: 0x06000E01 RID: 3585 RVA: 0x0003CA54 File Offset: 0x0003AC54
public object Current
{
get
{
if (this.currentElement != ArrayList.SimpleEnumerator.endFlag)
{
return this.currentElement;
}
if (this.index == -1)
{
throw new InvalidOperationException("Enumerator not started");
}
throw new InvalidOperationException("Enumerator ended");
}
}
// Token: 0x06000E02 RID: 3586 RVA: 0x0003CA9C File Offset: 0x0003AC9C
public void Reset()
{
if (this.version != this.list._version)
{
throw new InvalidOperationException("List has changed.");
}
this.currentElement = ArrayList.SimpleEnumerator.endFlag;
this.index = -1;
}
// Token: 0x04000398 RID: 920
private ArrayList list;
// Token: 0x04000399 RID: 921
private int index;
// Token: 0x0400039A RID: 922
private int version;
// Token: 0x0400039B RID: 923
private object currentElement;
// Token: 0x0400039C RID: 924
private static object endFlag = new object();
}
// Token: 0x02000116 RID: 278
[Serializable]
private sealed class ArrayListAdapter : ArrayList
{
// Token: 0x06000E03 RID: 3587 RVA: 0x0003CAD4 File Offset: 0x0003ACD4
public ArrayListAdapter(IList adaptee)
: base(0, true)
{
this.m_Adaptee = adaptee;
}
// Token: 0x1700021E RID: 542
public override object this[int index]
{
get
{
return this.m_Adaptee[index];
}
set
{
this.m_Adaptee[index] = value;
}
}
// Token: 0x1700021F RID: 543
// (get) Token: 0x06000E06 RID: 3590 RVA: 0x0003CB08 File Offset: 0x0003AD08
public override int Count
{
get
{
return this.m_Adaptee.Count;
}
}
// Token: 0x17000220 RID: 544
// (get) Token: 0x06000E07 RID: 3591 RVA: 0x0003CB18 File Offset: 0x0003AD18
// (set) Token: 0x06000E08 RID: 3592 RVA: 0x0003CB28 File Offset: 0x0003AD28
public override int Capacity
{
get
{
return this.m_Adaptee.Count;
}
set
{
if (value < this.m_Adaptee.Count)
{
throw new ArgumentException("capacity");
}
}
}
// Token: 0x17000221 RID: 545
// (get) Token: 0x06000E09 RID: 3593 RVA: 0x0003CB48 File Offset: 0x0003AD48
public override bool IsFixedSize
{
get
{
return this.m_Adaptee.IsFixedSize;
}
}
// Token: 0x17000222 RID: 546
// (get) Token: 0x06000E0A RID: 3594 RVA: 0x0003CB58 File Offset: 0x0003AD58
public override bool IsReadOnly
{
get
{
return this.m_Adaptee.IsReadOnly;
}
}
// Token: 0x17000223 RID: 547
// (get) Token: 0x06000E0B RID: 3595 RVA: 0x0003CB68 File Offset: 0x0003AD68
public override object SyncRoot
{
get
{
return this.m_Adaptee.SyncRoot;
}
}
// Token: 0x06000E0C RID: 3596 RVA: 0x0003CB78 File Offset: 0x0003AD78
public override int Add(object value)
{
return this.m_Adaptee.Add(value);
}
// Token: 0x06000E0D RID: 3597 RVA: 0x0003CB88 File Offset: 0x0003AD88
public override void Clear()
{
this.m_Adaptee.Clear();
}
// Token: 0x06000E0E RID: 3598 RVA: 0x0003CB98 File Offset: 0x0003AD98
public override bool Contains(object value)
{
return this.m_Adaptee.Contains(value);
}
// Token: 0x06000E0F RID: 3599 RVA: 0x0003CBA8 File Offset: 0x0003ADA8
public override int IndexOf(object value)
{
return this.m_Adaptee.IndexOf(value);
}
// Token: 0x06000E10 RID: 3600 RVA: 0x0003CBB8 File Offset: 0x0003ADB8
public override int IndexOf(object value, int startIndex)
{
return this.IndexOf(value, startIndex, this.m_Adaptee.Count - startIndex);
}
// Token: 0x06000E11 RID: 3601 RVA: 0x0003CBD0 File Offset: 0x0003ADD0
public override int IndexOf(object value, int startIndex, int count)
{
if (startIndex < 0 || startIndex > this.m_Adaptee.Count)
{
ArrayList.ThrowNewArgumentOutOfRangeException("startIndex", startIndex, "Does not specify valid index.");
}
if (count < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("count", count, "Can't be less than 0.");
}
if (startIndex > this.m_Adaptee.Count - count)
{
throw new ArgumentOutOfRangeException("count", "Start index and count do not specify a valid range.");
}
if (value == null)
{
for (int i = startIndex; i < startIndex + count; i++)
{
if (this.m_Adaptee[i] == null)
{
return i;
}
}
}
else
{
for (int j = startIndex; j < startIndex + count; j++)
{
if (value.Equals(this.m_Adaptee[j]))
{
return j;
}
}
}
return -1;
}
// Token: 0x06000E12 RID: 3602 RVA: 0x0003CCAC File Offset: 0x0003AEAC
public override int LastIndexOf(object value)
{
return this.LastIndexOf(value, this.m_Adaptee.Count - 1);
}
// Token: 0x06000E13 RID: 3603 RVA: 0x0003CCC4 File Offset: 0x0003AEC4
public override int LastIndexOf(object value, int startIndex)
{
return this.LastIndexOf(value, startIndex, startIndex + 1);
}
// Token: 0x06000E14 RID: 3604 RVA: 0x0003CCD4 File Offset: 0x0003AED4
public override int LastIndexOf(object value, int startIndex, int count)
{
if (startIndex < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("startIndex", startIndex, "< 0");
}
if (count < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("count", count, "count is negative.");
}
if (startIndex - count + 1 < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("count", count, "count is too large.");
}
if (value == null)
{
for (int i = startIndex; i > startIndex - count; i--)
{
if (this.m_Adaptee[i] == null)
{
return i;
}
}
}
else
{
for (int j = startIndex; j > startIndex - count; j--)
{
if (value.Equals(this.m_Adaptee[j]))
{
return j;
}
}
}
return -1;
}
// Token: 0x06000E15 RID: 3605 RVA: 0x0003CD9C File Offset: 0x0003AF9C
public override void Insert(int index, object value)
{
this.m_Adaptee.Insert(index, value);
}
// Token: 0x06000E16 RID: 3606 RVA: 0x0003CDAC File Offset: 0x0003AFAC
public override void InsertRange(int index, ICollection c)
{
if (c == null)
{
throw new ArgumentNullException("c");
}
if (index > this.m_Adaptee.Count)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index must be >= 0 and <= Count.");
}
foreach (object obj in c)
{
this.m_Adaptee.Insert(index++, obj);
}
}
// Token: 0x06000E17 RID: 3607 RVA: 0x0003CE54 File Offset: 0x0003B054
public override void Remove(object value)
{
this.m_Adaptee.Remove(value);
}
// Token: 0x06000E18 RID: 3608 RVA: 0x0003CE64 File Offset: 0x0003B064
public override void RemoveAt(int index)
{
this.m_Adaptee.RemoveAt(index);
}
// Token: 0x06000E19 RID: 3609 RVA: 0x0003CE74 File Offset: 0x0003B074
public override void RemoveRange(int index, int count)
{
ArrayList.CheckRange(index, count, this.m_Adaptee.Count);
for (int i = 0; i < count; i++)
{
this.m_Adaptee.RemoveAt(index);
}
}
// Token: 0x06000E1A RID: 3610 RVA: 0x0003CEB4 File Offset: 0x0003B0B4
public override void Reverse()
{
this.Reverse(0, this.m_Adaptee.Count);
}
// Token: 0x06000E1B RID: 3611 RVA: 0x0003CEC8 File Offset: 0x0003B0C8
public override void Reverse(int index, int count)
{
ArrayList.CheckRange(index, count, this.m_Adaptee.Count);
for (int i = 0; i < count / 2; i++)
{
object obj = this.m_Adaptee[i + index];
this.m_Adaptee[i + index] = this.m_Adaptee[index + count - i + index - 1];
this.m_Adaptee[index + count - i + index - 1] = obj;
}
}
// Token: 0x06000E1C RID: 3612 RVA: 0x0003CF44 File Offset: 0x0003B144
public override void SetRange(int index, ICollection c)
{
if (c == null)
{
throw new ArgumentNullException("c");
}
if (index < 0 || index + c.Count > this.m_Adaptee.Count)
{
throw new ArgumentOutOfRangeException("index");
}
int num = index;
foreach (object obj in c)
{
this.m_Adaptee[num++] = obj;
}
}
// Token: 0x06000E1D RID: 3613 RVA: 0x0003CFF0 File Offset: 0x0003B1F0
public override void CopyTo(Array array)
{
this.m_Adaptee.CopyTo(array, 0);
}
// Token: 0x06000E1E RID: 3614 RVA: 0x0003D000 File Offset: 0x0003B200
public override void CopyTo(Array array, int index)
{
this.m_Adaptee.CopyTo(array, index);
}
// Token: 0x06000E1F RID: 3615 RVA: 0x0003D010 File Offset: 0x0003B210
public override void CopyTo(int index, Array array, int arrayIndex, int count)
{
if (index < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Can't be less than zero.");
}
if (arrayIndex < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("arrayIndex", arrayIndex, "Can't be less than zero.");
}
if (count < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Can't be less than zero.");
}
if (index >= this.m_Adaptee.Count)
{
throw new ArgumentException("Can't be more or equal to list count.", "index");
}
if (array.Rank > 1)
{
throw new ArgumentException("Can't copy into multi-dimensional array.");
}
if (arrayIndex >= array.Length)
{
throw new ArgumentException("arrayIndex can't be greater than array.Length - 1.");
}
if (array.Length - arrayIndex + 1 < count)
{
throw new ArgumentException("Destination array is too small.");
}
if (index > this.m_Adaptee.Count - count)
{
throw new ArgumentException("Index and count do not denote a valid range of elements.", "index");
}
for (int i = 0; i < count; i++)
{
array.SetValue(this.m_Adaptee[index + i], arrayIndex + i);
}
}
// Token: 0x17000224 RID: 548
// (get) Token: 0x06000E20 RID: 3616 RVA: 0x0003D12C File Offset: 0x0003B32C
public override bool IsSynchronized
{
get
{
return this.m_Adaptee.IsSynchronized;
}
}
// Token: 0x06000E21 RID: 3617 RVA: 0x0003D13C File Offset: 0x0003B33C
public override IEnumerator GetEnumerator()
{
return this.m_Adaptee.GetEnumerator();
}
// Token: 0x06000E22 RID: 3618 RVA: 0x0003D14C File Offset: 0x0003B34C
public override IEnumerator GetEnumerator(int index, int count)
{
ArrayList.CheckRange(index, count, this.m_Adaptee.Count);
return new ArrayList.ArrayListAdapter.EnumeratorWithRange(this.m_Adaptee.GetEnumerator(), index, count);
}
// Token: 0x06000E23 RID: 3619 RVA: 0x0003D180 File Offset: 0x0003B380
public override void AddRange(ICollection c)
{
foreach (object obj in c)
{
this.m_Adaptee.Add(obj);
}
}
// Token: 0x06000E24 RID: 3620 RVA: 0x0003D1EC File Offset: 0x0003B3EC
public override int BinarySearch(object value)
{
return this.BinarySearch(value, null);
}
// Token: 0x06000E25 RID: 3621 RVA: 0x0003D1F8 File Offset: 0x0003B3F8
public override int BinarySearch(object value, IComparer comparer)
{
return this.BinarySearch(0, this.m_Adaptee.Count, value, comparer);
}
// Token: 0x06000E26 RID: 3622 RVA: 0x0003D210 File Offset: 0x0003B410
public override int BinarySearch(int index, int count, object value, IComparer comparer)
{
ArrayList.CheckRange(index, count, this.m_Adaptee.Count);
if (comparer == null)
{
comparer = Comparer.Default;
}
int i = index;
int num = index + count - 1;
while (i <= num)
{
int num2 = i + (num - i) / 2;
int num3 = comparer.Compare(value, this.m_Adaptee[num2]);
if (num3 < 0)
{
num = num2 - 1;
}
else
{
if (num3 <= 0)
{
return num2;
}
i = num2 + 1;
}
}
return ~i;
}
// Token: 0x06000E27 RID: 3623 RVA: 0x0003D294 File Offset: 0x0003B494
public override object Clone()
{
return new ArrayList.ArrayListAdapter(this.m_Adaptee);
}
// Token: 0x06000E28 RID: 3624 RVA: 0x0003D2A4 File Offset: 0x0003B4A4
public override ArrayList GetRange(int index, int count)
{
ArrayList.CheckRange(index, count, this.m_Adaptee.Count);
return new ArrayList.RangedArrayList(this, index, count);
}
// Token: 0x06000E29 RID: 3625 RVA: 0x0003D2C0 File Offset: 0x0003B4C0
public override void TrimToSize()
{
}
// Token: 0x06000E2A RID: 3626 RVA: 0x0003D2C4 File Offset: 0x0003B4C4
public override void Sort()
{
this.Sort(Comparer.Default);
}
// Token: 0x06000E2B RID: 3627 RVA: 0x0003D2D4 File Offset: 0x0003B4D4
public override void Sort(IComparer comparer)
{
this.Sort(0, this.m_Adaptee.Count, comparer);
}
// Token: 0x06000E2C RID: 3628 RVA: 0x0003D2EC File Offset: 0x0003B4EC
public override void Sort(int index, int count, IComparer comparer)
{
ArrayList.CheckRange(index, count, this.m_Adaptee.Count);
if (comparer == null)
{
comparer = Comparer.Default;
}
ArrayList.ArrayListAdapter.QuickSort(this.m_Adaptee, index, index + count - 1, comparer);
}
// Token: 0x06000E2D RID: 3629 RVA: 0x0003D32C File Offset: 0x0003B52C
private static void Swap(IList list, int x, int y)
{
object obj = list[x];
list[x] = list[y];
list[y] = obj;
}
// Token: 0x06000E2E RID: 3630 RVA: 0x0003D358 File Offset: 0x0003B558
internal static void QuickSort(IList list, int left, int right, IComparer comparer)
{
if (left >= right)
{
return;
}
int num = left + (right - left) / 2;
if (comparer.Compare(list[num], list[left]) < 0)
{
ArrayList.ArrayListAdapter.Swap(list, num, left);
}
if (comparer.Compare(list[right], list[left]) < 0)
{
ArrayList.ArrayListAdapter.Swap(list, right, left);
}
if (comparer.Compare(list[right], list[num]) < 0)
{
ArrayList.ArrayListAdapter.Swap(list, right, num);
}
if (right - left + 1 <= 3)
{
return;
}
ArrayList.ArrayListAdapter.Swap(list, right - 1, num);
object obj = list[right - 1];
int num2 = left;
int num3 = right - 1;
for (;;)
{
while (comparer.Compare(list[++num2], obj) < 0)
{
}
while (comparer.Compare(list[--num3], obj) > 0)
{
}
if (num2 >= num3)
{
break;
}
ArrayList.ArrayListAdapter.Swap(list, num2, num3);
}
ArrayList.ArrayListAdapter.Swap(list, right - 1, num2);
ArrayList.ArrayListAdapter.QuickSort(list, left, num2 - 1, comparer);
ArrayList.ArrayListAdapter.QuickSort(list, num2 + 1, right, comparer);
}
// Token: 0x06000E2F RID: 3631 RVA: 0x0003D480 File Offset: 0x0003B680
public override object[] ToArray()
{
object[] array = new object[this.m_Adaptee.Count];
this.m_Adaptee.CopyTo(array, 0);
return array;
}
// Token: 0x06000E30 RID: 3632 RVA: 0x0003D4AC File Offset: 0x0003B6AC
public override Array ToArray(Type elementType)
{
Array array = Array.CreateInstance(elementType, this.m_Adaptee.Count);
this.m_Adaptee.CopyTo(array, 0);
return array;
}
// Token: 0x0400039D RID: 925
private IList m_Adaptee;
// Token: 0x02000117 RID: 279
private sealed class EnumeratorWithRange : IEnumerator, ICloneable
{
// Token: 0x06000E31 RID: 3633 RVA: 0x0003D4DC File Offset: 0x0003B6DC
public EnumeratorWithRange(IEnumerator enumerator, int index, int count)
{
this.m_Count = 0;
this.m_StartIndex = index;
this.m_MaxCount = count;
this.m_Enumerator = enumerator;
this.Reset();
}
// Token: 0x06000E32 RID: 3634 RVA: 0x0003D514 File Offset: 0x0003B714
public object Clone()
{
return base.MemberwiseClone();
}
// Token: 0x17000225 RID: 549
// (get) Token: 0x06000E33 RID: 3635 RVA: 0x0003D51C File Offset: 0x0003B71C
public object Current
{
get
{
return this.m_Enumerator.Current;
}
}
// Token: 0x06000E34 RID: 3636 RVA: 0x0003D52C File Offset: 0x0003B72C
public bool MoveNext()
{
if (this.m_Count >= this.m_MaxCount)
{
return false;
}
this.m_Count++;
return this.m_Enumerator.MoveNext();
}
// Token: 0x06000E35 RID: 3637 RVA: 0x0003D568 File Offset: 0x0003B768
public void Reset()
{
this.m_Count = 0;
this.m_Enumerator.Reset();
for (int i = 0; i < this.m_StartIndex; i++)
{
this.m_Enumerator.MoveNext();
}
}
// Token: 0x0400039E RID: 926
private int m_StartIndex;
// Token: 0x0400039F RID: 927
private int m_Count;
// Token: 0x040003A0 RID: 928
private int m_MaxCount;
// Token: 0x040003A1 RID: 929
private IEnumerator m_Enumerator;
}
}
// Token: 0x02000118 RID: 280
[Serializable]
private class ArrayListWrapper : ArrayList
{
// Token: 0x06000E36 RID: 3638 RVA: 0x0003D5AC File Offset: 0x0003B7AC
public ArrayListWrapper(ArrayList innerArrayList)
{
this.m_InnerArrayList = innerArrayList;
}
// Token: 0x17000226 RID: 550
public override object this[int index]
{
get
{
return this.m_InnerArrayList[index];
}
set
{
this.m_InnerArrayList[index] = value;
}
}
// Token: 0x17000227 RID: 551
// (get) Token: 0x06000E39 RID: 3641 RVA: 0x0003D5DC File Offset: 0x0003B7DC
public override int Count
{
get
{
return this.m_InnerArrayList.Count;
}
}
// Token: 0x17000228 RID: 552
// (get) Token: 0x06000E3A RID: 3642 RVA: 0x0003D5EC File Offset: 0x0003B7EC
// (set) Token: 0x06000E3B RID: 3643 RVA: 0x0003D5FC File Offset: 0x0003B7FC
public override int Capacity
{
get
{
return this.m_InnerArrayList.Capacity;
}
set
{
this.m_InnerArrayList.Capacity = value;
}
}
// Token: 0x17000229 RID: 553
// (get) Token: 0x06000E3C RID: 3644 RVA: 0x0003D60C File Offset: 0x0003B80C
public override bool IsFixedSize
{
get
{
return this.m_InnerArrayList.IsFixedSize;
}
}
// Token: 0x1700022A RID: 554
// (get) Token: 0x06000E3D RID: 3645 RVA: 0x0003D61C File Offset: 0x0003B81C
public override bool IsReadOnly
{
get
{
return this.m_InnerArrayList.IsReadOnly;
}
}
// Token: 0x1700022B RID: 555
// (get) Token: 0x06000E3E RID: 3646 RVA: 0x0003D62C File Offset: 0x0003B82C
public override bool IsSynchronized
{
get
{
return this.m_InnerArrayList.IsSynchronized;
}
}
// Token: 0x1700022C RID: 556
// (get) Token: 0x06000E3F RID: 3647 RVA: 0x0003D63C File Offset: 0x0003B83C
public override object SyncRoot
{
get
{
return this.m_InnerArrayList.SyncRoot;
}
}
// Token: 0x06000E40 RID: 3648 RVA: 0x0003D64C File Offset: 0x0003B84C
public override int Add(object value)
{
return this.m_InnerArrayList.Add(value);
}
// Token: 0x06000E41 RID: 3649 RVA: 0x0003D65C File Offset: 0x0003B85C
public override void Clear()
{
this.m_InnerArrayList.Clear();
}
// Token: 0x06000E42 RID: 3650 RVA: 0x0003D66C File Offset: 0x0003B86C
public override bool Contains(object value)
{
return this.m_InnerArrayList.Contains(value);
}
// Token: 0x06000E43 RID: 3651 RVA: 0x0003D67C File Offset: 0x0003B87C
public override int IndexOf(object value)
{
return this.m_InnerArrayList.IndexOf(value);
}
// Token: 0x06000E44 RID: 3652 RVA: 0x0003D68C File Offset: 0x0003B88C
public override int IndexOf(object value, int startIndex)
{
return this.m_InnerArrayList.IndexOf(value, startIndex);
}
// Token: 0x06000E45 RID: 3653 RVA: 0x0003D69C File Offset: 0x0003B89C
public override int IndexOf(object value, int startIndex, int count)
{
return this.m_InnerArrayList.IndexOf(value, startIndex, count);
}
// Token: 0x06000E46 RID: 3654 RVA: 0x0003D6AC File Offset: 0x0003B8AC
public override int LastIndexOf(object value)
{
return this.m_InnerArrayList.LastIndexOf(value);
}
// Token: 0x06000E47 RID: 3655 RVA: 0x0003D6BC File Offset: 0x0003B8BC
public override int LastIndexOf(object value, int startIndex)
{
return this.m_InnerArrayList.LastIndexOf(value, startIndex);
}
// Token: 0x06000E48 RID: 3656 RVA: 0x0003D6CC File Offset: 0x0003B8CC
public override int LastIndexOf(object value, int startIndex, int count)
{
return this.m_InnerArrayList.LastIndexOf(value, startIndex, count);
}
// Token: 0x06000E49 RID: 3657 RVA: 0x0003D6DC File Offset: 0x0003B8DC
public override void Insert(int index, object value)
{
this.m_InnerArrayList.Insert(index, value);
}
// Token: 0x06000E4A RID: 3658 RVA: 0x0003D6EC File Offset: 0x0003B8EC
public override void InsertRange(int index, ICollection c)
{
this.m_InnerArrayList.InsertRange(index, c);
}
// Token: 0x06000E4B RID: 3659 RVA: 0x0003D6FC File Offset: 0x0003B8FC
public override void Remove(object value)
{
this.m_InnerArrayList.Remove(value);
}
// Token: 0x06000E4C RID: 3660 RVA: 0x0003D70C File Offset: 0x0003B90C
public override void RemoveAt(int index)
{
this.m_InnerArrayList.RemoveAt(index);
}
// Token: 0x06000E4D RID: 3661 RVA: 0x0003D71C File Offset: 0x0003B91C
public override void RemoveRange(int index, int count)
{
this.m_InnerArrayList.RemoveRange(index, count);
}
// Token: 0x06000E4E RID: 3662 RVA: 0x0003D72C File Offset: 0x0003B92C
public override void Reverse()
{
this.m_InnerArrayList.Reverse();
}
// Token: 0x06000E4F RID: 3663 RVA: 0x0003D73C File Offset: 0x0003B93C
public override void Reverse(int index, int count)
{
this.m_InnerArrayList.Reverse(index, count);
}
// Token: 0x06000E50 RID: 3664 RVA: 0x0003D74C File Offset: 0x0003B94C
public override void SetRange(int index, ICollection c)
{
this.m_InnerArrayList.SetRange(index, c);
}
// Token: 0x06000E51 RID: 3665 RVA: 0x0003D75C File Offset: 0x0003B95C
public override void CopyTo(Array array)
{
this.m_InnerArrayList.CopyTo(array);
}
// Token: 0x06000E52 RID: 3666 RVA: 0x0003D76C File Offset: 0x0003B96C
public override void CopyTo(Array array, int index)
{
this.m_InnerArrayList.CopyTo(array, index);
}
// Token: 0x06000E53 RID: 3667 RVA: 0x0003D77C File Offset: 0x0003B97C
public override void CopyTo(int index, Array array, int arrayIndex, int count)
{
this.m_InnerArrayList.CopyTo(index, array, arrayIndex, count);
}
// Token: 0x06000E54 RID: 3668 RVA: 0x0003D790 File Offset: 0x0003B990
public override IEnumerator GetEnumerator()
{
return this.m_InnerArrayList.GetEnumerator();
}
// Token: 0x06000E55 RID: 3669 RVA: 0x0003D7A0 File Offset: 0x0003B9A0
public override IEnumerator GetEnumerator(int index, int count)
{
return this.m_InnerArrayList.GetEnumerator(index, count);
}
// Token: 0x06000E56 RID: 3670 RVA: 0x0003D7B0 File Offset: 0x0003B9B0
public override void AddRange(ICollection c)
{
this.m_InnerArrayList.AddRange(c);
}
// Token: 0x06000E57 RID: 3671 RVA: 0x0003D7C0 File Offset: 0x0003B9C0
public override int BinarySearch(object value)
{
return this.m_InnerArrayList.BinarySearch(value);
}
// Token: 0x06000E58 RID: 3672 RVA: 0x0003D7D0 File Offset: 0x0003B9D0
public override int BinarySearch(object value, IComparer comparer)
{
return this.m_InnerArrayList.BinarySearch(value, comparer);
}
// Token: 0x06000E59 RID: 3673 RVA: 0x0003D7E0 File Offset: 0x0003B9E0
public override int BinarySearch(int index, int count, object value, IComparer comparer)
{
return this.m_InnerArrayList.BinarySearch(index, count, value, comparer);
}
// Token: 0x06000E5A RID: 3674 RVA: 0x0003D7F4 File Offset: 0x0003B9F4
public override object Clone()
{
return this.m_InnerArrayList.Clone();
}
// Token: 0x06000E5B RID: 3675 RVA: 0x0003D804 File Offset: 0x0003BA04
public override ArrayList GetRange(int index, int count)
{
return this.m_InnerArrayList.GetRange(index, count);
}
// Token: 0x06000E5C RID: 3676 RVA: 0x0003D814 File Offset: 0x0003BA14
public override void TrimToSize()
{
this.m_InnerArrayList.TrimToSize();
}
// Token: 0x06000E5D RID: 3677 RVA: 0x0003D824 File Offset: 0x0003BA24
public override void Sort()
{
this.m_InnerArrayList.Sort();
}
// Token: 0x06000E5E RID: 3678 RVA: 0x0003D834 File Offset: 0x0003BA34
public override void Sort(IComparer comparer)
{
this.m_InnerArrayList.Sort(comparer);
}
// Token: 0x06000E5F RID: 3679 RVA: 0x0003D844 File Offset: 0x0003BA44
public override void Sort(int index, int count, IComparer comparer)
{
this.m_InnerArrayList.Sort(index, count, comparer);
}
// Token: 0x06000E60 RID: 3680 RVA: 0x0003D854 File Offset: 0x0003BA54
public override object[] ToArray()
{
return this.m_InnerArrayList.ToArray();
}
// Token: 0x06000E61 RID: 3681 RVA: 0x0003D864 File Offset: 0x0003BA64
public override Array ToArray(Type elementType)
{
return this.m_InnerArrayList.ToArray(elementType);
}
// Token: 0x040003A2 RID: 930
protected ArrayList m_InnerArrayList;
}
// Token: 0x02000119 RID: 281
[Serializable]
private sealed class SynchronizedArrayListWrapper : ArrayList.ArrayListWrapper
{
// Token: 0x06000E62 RID: 3682 RVA: 0x0003D874 File Offset: 0x0003BA74
internal SynchronizedArrayListWrapper(ArrayList innerArrayList)
: base(innerArrayList)
{
this.m_SyncRoot = innerArrayList.SyncRoot;
}
// Token: 0x1700022D RID: 557
public override object this[int index]
{
get
{
object syncRoot = this.m_SyncRoot;
object obj;
lock (syncRoot)
{
obj = this.m_InnerArrayList[index];
}
return obj;
}
set
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList[index] = value;
}
}
}
// Token: 0x1700022E RID: 558
// (get) Token: 0x06000E65 RID: 3685 RVA: 0x0003D934 File Offset: 0x0003BB34
public override int Count
{
get
{
object syncRoot = this.m_SyncRoot;
int count;
lock (syncRoot)
{
count = this.m_InnerArrayList.Count;
}
return count;
}
}
// Token: 0x1700022F RID: 559
// (get) Token: 0x06000E66 RID: 3686 RVA: 0x0003D988 File Offset: 0x0003BB88
// (set) Token: 0x06000E67 RID: 3687 RVA: 0x0003D9DC File Offset: 0x0003BBDC
public override int Capacity
{
get
{
object syncRoot = this.m_SyncRoot;
int capacity;
lock (syncRoot)
{
capacity = this.m_InnerArrayList.Capacity;
}
return capacity;
}
set
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Capacity = value;
}
}
}
// Token: 0x17000230 RID: 560
// (get) Token: 0x06000E68 RID: 3688 RVA: 0x0003DA2C File Offset: 0x0003BC2C
public override bool IsFixedSize
{
get
{
object syncRoot = this.m_SyncRoot;
bool isFixedSize;
lock (syncRoot)
{
isFixedSize = this.m_InnerArrayList.IsFixedSize;
}
return isFixedSize;
}
}
// Token: 0x17000231 RID: 561
// (get) Token: 0x06000E69 RID: 3689 RVA: 0x0003DA80 File Offset: 0x0003BC80
public override bool IsReadOnly
{
get
{
object syncRoot = this.m_SyncRoot;
bool isReadOnly;
lock (syncRoot)
{
isReadOnly = this.m_InnerArrayList.IsReadOnly;
}
return isReadOnly;
}
}
// Token: 0x17000232 RID: 562
// (get) Token: 0x06000E6A RID: 3690 RVA: 0x0003DAD4 File Offset: 0x0003BCD4
public override bool IsSynchronized
{
get
{
return true;
}
}
// Token: 0x17000233 RID: 563
// (get) Token: 0x06000E6B RID: 3691 RVA: 0x0003DAD8 File Offset: 0x0003BCD8
public override object SyncRoot
{
get
{
return this.m_SyncRoot;
}
}
// Token: 0x06000E6C RID: 3692 RVA: 0x0003DAE0 File Offset: 0x0003BCE0
public override int Add(object value)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.Add(value);
}
return num;
}
// Token: 0x06000E6D RID: 3693 RVA: 0x0003DB38 File Offset: 0x0003BD38
public override void Clear()
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Clear();
}
}
// Token: 0x06000E6E RID: 3694 RVA: 0x0003DB88 File Offset: 0x0003BD88
public override bool Contains(object value)
{
object syncRoot = this.m_SyncRoot;
bool flag;
lock (syncRoot)
{
flag = this.m_InnerArrayList.Contains(value);
}
return flag;
}
// Token: 0x06000E6F RID: 3695 RVA: 0x0003DBE0 File Offset: 0x0003BDE0
public override int IndexOf(object value)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.IndexOf(value);
}
return num;
}
// Token: 0x06000E70 RID: 3696 RVA: 0x0003DC38 File Offset: 0x0003BE38
public override int IndexOf(object value, int startIndex)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.IndexOf(value, startIndex);
}
return num;
}
// Token: 0x06000E71 RID: 3697 RVA: 0x0003DC90 File Offset: 0x0003BE90
public override int IndexOf(object value, int startIndex, int count)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.IndexOf(value, startIndex, count);
}
return num;
}
// Token: 0x06000E72 RID: 3698 RVA: 0x0003DCE8 File Offset: 0x0003BEE8
public override int LastIndexOf(object value)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.LastIndexOf(value);
}
return num;
}
// Token: 0x06000E73 RID: 3699 RVA: 0x0003DD40 File Offset: 0x0003BF40
public override int LastIndexOf(object value, int startIndex)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.LastIndexOf(value, startIndex);
}
return num;
}
// Token: 0x06000E74 RID: 3700 RVA: 0x0003DD98 File Offset: 0x0003BF98
public override int LastIndexOf(object value, int startIndex, int count)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.LastIndexOf(value, startIndex, count);
}
return num;
}
// Token: 0x06000E75 RID: 3701 RVA: 0x0003DDF0 File Offset: 0x0003BFF0
public override void Insert(int index, object value)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Insert(index, value);
}
}
// Token: 0x06000E76 RID: 3702 RVA: 0x0003DE40 File Offset: 0x0003C040
public override void InsertRange(int index, ICollection c)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.InsertRange(index, c);
}
}
// Token: 0x06000E77 RID: 3703 RVA: 0x0003DE90 File Offset: 0x0003C090
public override void Remove(object value)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Remove(value);
}
}
// Token: 0x06000E78 RID: 3704 RVA: 0x0003DEE0 File Offset: 0x0003C0E0
public override void RemoveAt(int index)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.RemoveAt(index);
}
}
// Token: 0x06000E79 RID: 3705 RVA: 0x0003DF30 File Offset: 0x0003C130
public override void RemoveRange(int index, int count)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.RemoveRange(index, count);
}
}
// Token: 0x06000E7A RID: 3706 RVA: 0x0003DF80 File Offset: 0x0003C180
public override void Reverse()
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Reverse();
}
}
// Token: 0x06000E7B RID: 3707 RVA: 0x0003DFD0 File Offset: 0x0003C1D0
public override void Reverse(int index, int count)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Reverse(index, count);
}
}
// Token: 0x06000E7C RID: 3708 RVA: 0x0003E020 File Offset: 0x0003C220
public override void CopyTo(Array array)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.CopyTo(array);
}
}
// Token: 0x06000E7D RID: 3709 RVA: 0x0003E070 File Offset: 0x0003C270
public override void CopyTo(Array array, int index)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.CopyTo(array, index);
}
}
// Token: 0x06000E7E RID: 3710 RVA: 0x0003E0C0 File Offset: 0x0003C2C0
public override void CopyTo(int index, Array array, int arrayIndex, int count)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.CopyTo(index, array, arrayIndex, count);
}
}
// Token: 0x06000E7F RID: 3711 RVA: 0x0003E114 File Offset: 0x0003C314
public override IEnumerator GetEnumerator()
{
object syncRoot = this.m_SyncRoot;
IEnumerator enumerator;
lock (syncRoot)
{
enumerator = this.m_InnerArrayList.GetEnumerator();
}
return enumerator;
}
// Token: 0x06000E80 RID: 3712 RVA: 0x0003E168 File Offset: 0x0003C368
public override IEnumerator GetEnumerator(int index, int count)
{
object syncRoot = this.m_SyncRoot;
IEnumerator enumerator;
lock (syncRoot)
{
enumerator = this.m_InnerArrayList.GetEnumerator(index, count);
}
return enumerator;
}
// Token: 0x06000E81 RID: 3713 RVA: 0x0003E1C0 File Offset: 0x0003C3C0
public override void AddRange(ICollection c)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.AddRange(c);
}
}
// Token: 0x06000E82 RID: 3714 RVA: 0x0003E210 File Offset: 0x0003C410
public override int BinarySearch(object value)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.BinarySearch(value);
}
return num;
}
// Token: 0x06000E83 RID: 3715 RVA: 0x0003E268 File Offset: 0x0003C468
public override int BinarySearch(object value, IComparer comparer)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.BinarySearch(value, comparer);
}
return num;
}
// Token: 0x06000E84 RID: 3716 RVA: 0x0003E2C0 File Offset: 0x0003C4C0
public override int BinarySearch(int index, int count, object value, IComparer comparer)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerArrayList.BinarySearch(index, count, value, comparer);
}
return num;
}
// Token: 0x06000E85 RID: 3717 RVA: 0x0003E31C File Offset: 0x0003C51C
public override object Clone()
{
object syncRoot = this.m_SyncRoot;
object obj;
lock (syncRoot)
{
obj = this.m_InnerArrayList.Clone();
}
return obj;
}
// Token: 0x06000E86 RID: 3718 RVA: 0x0003E370 File Offset: 0x0003C570
public override ArrayList GetRange(int index, int count)
{
object syncRoot = this.m_SyncRoot;
ArrayList range;
lock (syncRoot)
{
range = this.m_InnerArrayList.GetRange(index, count);
}
return range;
}
// Token: 0x06000E87 RID: 3719 RVA: 0x0003E3C8 File Offset: 0x0003C5C8
public override void TrimToSize()
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.TrimToSize();
}
}
// Token: 0x06000E88 RID: 3720 RVA: 0x0003E418 File Offset: 0x0003C618
public override void Sort()
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Sort();
}
}
// Token: 0x06000E89 RID: 3721 RVA: 0x0003E468 File Offset: 0x0003C668
public override void Sort(IComparer comparer)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Sort(comparer);
}
}
// Token: 0x06000E8A RID: 3722 RVA: 0x0003E4B8 File Offset: 0x0003C6B8
public override void Sort(int index, int count, IComparer comparer)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerArrayList.Sort(index, count, comparer);
}
}
// Token: 0x06000E8B RID: 3723 RVA: 0x0003E508 File Offset: 0x0003C708
public override object[] ToArray()
{
object syncRoot = this.m_SyncRoot;
object[] array;
lock (syncRoot)
{
array = this.m_InnerArrayList.ToArray();
}
return array;
}
// Token: 0x06000E8C RID: 3724 RVA: 0x0003E55C File Offset: 0x0003C75C
public override Array ToArray(Type elementType)
{
object syncRoot = this.m_SyncRoot;
Array array;
lock (syncRoot)
{
array = this.m_InnerArrayList.ToArray(elementType);
}
return array;
}
// Token: 0x040003A3 RID: 931
private object m_SyncRoot;
}
// Token: 0x0200011A RID: 282
[Serializable]
private class FixedSizeArrayListWrapper : ArrayList.ArrayListWrapper
{
// Token: 0x06000E8D RID: 3725 RVA: 0x0003E5B4 File Offset: 0x0003C7B4
public FixedSizeArrayListWrapper(ArrayList innerList)
: base(innerList)
{
}
// Token: 0x17000234 RID: 564
// (get) Token: 0x06000E8E RID: 3726 RVA: 0x0003E5C0 File Offset: 0x0003C7C0
protected virtual string ErrorMessage
{
get
{
return "Can't add or remove from a fixed-size list.";
}
}
// Token: 0x17000235 RID: 565
// (get) Token: 0x06000E8F RID: 3727 RVA: 0x0003E5C8 File Offset: 0x0003C7C8
// (set) Token: 0x06000E90 RID: 3728 RVA: 0x0003E5D0 File Offset: 0x0003C7D0
public override int Capacity
{
get
{
return base.Capacity;
}
set
{
throw new NotSupportedException(this.ErrorMessage);
}
}
// Token: 0x17000236 RID: 566
// (get) Token: 0x06000E91 RID: 3729 RVA: 0x0003E5E0 File Offset: 0x0003C7E0
public override bool IsFixedSize
{
get
{
return true;
}
}
// Token: 0x06000E92 RID: 3730 RVA: 0x0003E5E4 File Offset: 0x0003C7E4
public override int Add(object value)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E93 RID: 3731 RVA: 0x0003E5F4 File Offset: 0x0003C7F4
public override void AddRange(ICollection c)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E94 RID: 3732 RVA: 0x0003E604 File Offset: 0x0003C804
public override void Clear()
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E95 RID: 3733 RVA: 0x0003E614 File Offset: 0x0003C814
public override void Insert(int index, object value)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E96 RID: 3734 RVA: 0x0003E624 File Offset: 0x0003C824
public override void InsertRange(int index, ICollection c)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E97 RID: 3735 RVA: 0x0003E634 File Offset: 0x0003C834
public override void Remove(object value)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E98 RID: 3736 RVA: 0x0003E644 File Offset: 0x0003C844
public override void RemoveAt(int index)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E99 RID: 3737 RVA: 0x0003E654 File Offset: 0x0003C854
public override void RemoveRange(int index, int count)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000E9A RID: 3738 RVA: 0x0003E664 File Offset: 0x0003C864
public override void TrimToSize()
{
throw new NotSupportedException(this.ErrorMessage);
}
}
// Token: 0x0200011B RID: 283
[Serializable]
private sealed class ReadOnlyArrayListWrapper : ArrayList.FixedSizeArrayListWrapper
{
// Token: 0x06000E9B RID: 3739 RVA: 0x0003E674 File Offset: 0x0003C874
public ReadOnlyArrayListWrapper(ArrayList innerArrayList)
: base(innerArrayList)
{
}
// Token: 0x17000237 RID: 567
// (get) Token: 0x06000E9C RID: 3740 RVA: 0x0003E680 File Offset: 0x0003C880
protected override string ErrorMessage
{
get
{
return "Can't modify a readonly list.";
}
}
// Token: 0x17000238 RID: 568
// (get) Token: 0x06000E9D RID: 3741 RVA: 0x0003E688 File Offset: 0x0003C888
public override bool IsReadOnly
{
get
{
return true;
}
}
// Token: 0x17000239 RID: 569
public override object this[int index]
{
get
{
return this.m_InnerArrayList[index];
}
set
{
throw new NotSupportedException(this.ErrorMessage);
}
}
// Token: 0x06000EA0 RID: 3744 RVA: 0x0003E6AC File Offset: 0x0003C8AC
public override void Reverse()
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EA1 RID: 3745 RVA: 0x0003E6BC File Offset: 0x0003C8BC
public override void Reverse(int index, int count)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EA2 RID: 3746 RVA: 0x0003E6CC File Offset: 0x0003C8CC
public override void SetRange(int index, ICollection c)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EA3 RID: 3747 RVA: 0x0003E6DC File Offset: 0x0003C8DC
public override void Sort()
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EA4 RID: 3748 RVA: 0x0003E6EC File Offset: 0x0003C8EC
public override void Sort(IComparer comparer)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EA5 RID: 3749 RVA: 0x0003E6FC File Offset: 0x0003C8FC
public override void Sort(int index, int count, IComparer comparer)
{
throw new NotSupportedException(this.ErrorMessage);
}
}
// Token: 0x0200011C RID: 284
[Serializable]
private sealed class RangedArrayList : ArrayList.ArrayListWrapper
{
// Token: 0x06000EA6 RID: 3750 RVA: 0x0003E70C File Offset: 0x0003C90C
public RangedArrayList(ArrayList innerList, int index, int count)
: base(innerList)
{
this.m_InnerIndex = index;
this.m_InnerCount = count;
this.m_InnerStateChanges = innerList._version;
}
// Token: 0x1700023A RID: 570
// (get) Token: 0x06000EA7 RID: 3751 RVA: 0x0003E730 File Offset: 0x0003C930
public override bool IsSynchronized
{
get
{
return false;
}
}
// Token: 0x1700023B RID: 571
public override object this[int index]
{
get
{
if (index < 0 || index > this.m_InnerCount)
{
throw new ArgumentOutOfRangeException("index");
}
return this.m_InnerArrayList[this.m_InnerIndex + index];
}
set
{
if (index < 0 || index > this.m_InnerCount)
{
throw new ArgumentOutOfRangeException("index");
}
this.m_InnerArrayList[this.m_InnerIndex + index] = value;
}
}
// Token: 0x1700023C RID: 572
// (get) Token: 0x06000EAA RID: 3754 RVA: 0x0003E7A8 File Offset: 0x0003C9A8
public override int Count
{
get
{
this.VerifyStateChanges();
return this.m_InnerCount;
}
}
// Token: 0x1700023D RID: 573
// (get) Token: 0x06000EAB RID: 3755 RVA: 0x0003E7B8 File Offset: 0x0003C9B8
// (set) Token: 0x06000EAC RID: 3756 RVA: 0x0003E7C8 File Offset: 0x0003C9C8
public override int Capacity
{
get
{
return this.m_InnerArrayList.Capacity;
}
set
{
if (value < this.m_InnerCount)
{
throw new ArgumentOutOfRangeException();
}
}
}
// Token: 0x06000EAD RID: 3757 RVA: 0x0003E7DC File Offset: 0x0003C9DC
private void VerifyStateChanges()
{
if (this.m_InnerStateChanges != this.m_InnerArrayList._version)
{
throw new InvalidOperationException("ArrayList view is invalid because the underlying ArrayList was modified.");
}
}
// Token: 0x06000EAE RID: 3758 RVA: 0x0003E800 File Offset: 0x0003CA00
public override int Add(object value)
{
this.VerifyStateChanges();
this.m_InnerArrayList.Insert(this.m_InnerIndex + this.m_InnerCount, value);
this.m_InnerStateChanges = this.m_InnerArrayList._version;
return ++this.m_InnerCount;
}
// Token: 0x06000EAF RID: 3759 RVA: 0x0003E850 File Offset: 0x0003CA50
public override void Clear()
{
this.VerifyStateChanges();
this.m_InnerArrayList.RemoveRange(this.m_InnerIndex, this.m_InnerCount);
this.m_InnerCount = 0;
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EB0 RID: 3760 RVA: 0x0003E894 File Offset: 0x0003CA94
public override bool Contains(object value)
{
return this.m_InnerArrayList.Contains(value, this.m_InnerIndex, this.m_InnerCount);
}
// Token: 0x06000EB1 RID: 3761 RVA: 0x0003E8B0 File Offset: 0x0003CAB0
public override int IndexOf(object value)
{
return this.IndexOf(value, 0);
}
// Token: 0x06000EB2 RID: 3762 RVA: 0x0003E8BC File Offset: 0x0003CABC
public override int IndexOf(object value, int startIndex)
{
return this.IndexOf(value, startIndex, this.m_InnerCount - startIndex);
}
// Token: 0x06000EB3 RID: 3763 RVA: 0x0003E8D0 File Offset: 0x0003CAD0
public override int IndexOf(object value, int startIndex, int count)
{
if (startIndex < 0 || startIndex > this.m_InnerCount)
{
ArrayList.ThrowNewArgumentOutOfRangeException("startIndex", startIndex, "Does not specify valid index.");
}
if (count < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("count", count, "Can't be less than 0.");
}
if (startIndex > this.m_InnerCount - count)
{
throw new ArgumentOutOfRangeException("count", "Start index and count do not specify a valid range.");
}
int num = this.m_InnerArrayList.IndexOf(value, this.m_InnerIndex + startIndex, count);
if (num == -1)
{
return -1;
}
return num - this.m_InnerIndex;
}
// Token: 0x06000EB4 RID: 3764 RVA: 0x0003E968 File Offset: 0x0003CB68
public override int LastIndexOf(object value)
{
return this.LastIndexOf(value, this.m_InnerCount - 1);
}
// Token: 0x06000EB5 RID: 3765 RVA: 0x0003E97C File Offset: 0x0003CB7C
public override int LastIndexOf(object value, int startIndex)
{
return this.LastIndexOf(value, startIndex, startIndex + 1);
}
// Token: 0x06000EB6 RID: 3766 RVA: 0x0003E98C File Offset: 0x0003CB8C
public override int LastIndexOf(object value, int startIndex, int count)
{
if (startIndex < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("startIndex", startIndex, "< 0");
}
if (count < 0)
{
ArrayList.ThrowNewArgumentOutOfRangeException("count", count, "count is negative.");
}
int num = this.m_InnerArrayList.LastIndexOf(value, this.m_InnerIndex + startIndex, count);
if (num == -1)
{
return -1;
}
return num - this.m_InnerIndex;
}
// Token: 0x06000EB7 RID: 3767 RVA: 0x0003E9F8 File Offset: 0x0003CBF8
public override void Insert(int index, object value)
{
this.VerifyStateChanges();
if (index < 0 || index > this.m_InnerCount)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index must be >= 0 and <= Count.");
}
this.m_InnerArrayList.Insert(this.m_InnerIndex + index, value);
this.m_InnerCount++;
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EB8 RID: 3768 RVA: 0x0003EA68 File Offset: 0x0003CC68
public override void InsertRange(int index, ICollection c)
{
this.VerifyStateChanges();
if (index < 0 || index > this.m_InnerCount)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index must be >= 0 and <= Count.");
}
this.m_InnerArrayList.InsertRange(this.m_InnerIndex + index, c);
this.m_InnerCount += c.Count;
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EB9 RID: 3769 RVA: 0x0003EADC File Offset: 0x0003CCDC
public override void Remove(object value)
{
this.VerifyStateChanges();
int num = this.IndexOf(value);
if (num > -1)
{
this.RemoveAt(num);
}
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EBA RID: 3770 RVA: 0x0003EB18 File Offset: 0x0003CD18
public override void RemoveAt(int index)
{
this.VerifyStateChanges();
if (index < 0 || index > this.m_InnerCount)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index must be >= 0 and <= Count.");
}
this.m_InnerArrayList.RemoveAt(this.m_InnerIndex + index);
this.m_InnerCount--;
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EBB RID: 3771 RVA: 0x0003EB88 File Offset: 0x0003CD88
public override void RemoveRange(int index, int count)
{
this.VerifyStateChanges();
ArrayList.CheckRange(index, count, this.m_InnerCount);
this.m_InnerArrayList.RemoveRange(this.m_InnerIndex + index, count);
this.m_InnerCount -= count;
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EBC RID: 3772 RVA: 0x0003EBDC File Offset: 0x0003CDDC
public override void Reverse()
{
this.Reverse(0, this.m_InnerCount);
}
// Token: 0x06000EBD RID: 3773 RVA: 0x0003EBEC File Offset: 0x0003CDEC
public override void Reverse(int index, int count)
{
this.VerifyStateChanges();
ArrayList.CheckRange(index, count, this.m_InnerCount);
this.m_InnerArrayList.Reverse(this.m_InnerIndex + index, count);
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EBE RID: 3774 RVA: 0x0003EC34 File Offset: 0x0003CE34
public override void SetRange(int index, ICollection c)
{
this.VerifyStateChanges();
if (index < 0 || index > this.m_InnerCount)
{
ArrayList.ThrowNewArgumentOutOfRangeException("index", index, "Index must be >= 0 and <= Count.");
}
this.m_InnerArrayList.SetRange(this.m_InnerIndex + index, c);
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EBF RID: 3775 RVA: 0x0003EC94 File Offset: 0x0003CE94
public override void CopyTo(Array array)
{
this.CopyTo(array, 0);
}
// Token: 0x06000EC0 RID: 3776 RVA: 0x0003ECA0 File Offset: 0x0003CEA0
public override void CopyTo(Array array, int index)
{
this.CopyTo(0, array, index, this.m_InnerCount);
}
// Token: 0x06000EC1 RID: 3777 RVA: 0x0003ECB4 File Offset: 0x0003CEB4
public override void CopyTo(int index, Array array, int arrayIndex, int count)
{
ArrayList.CheckRange(index, count, this.m_InnerCount);
this.m_InnerArrayList.CopyTo(this.m_InnerIndex + index, array, arrayIndex, count);
}
// Token: 0x06000EC2 RID: 3778 RVA: 0x0003ECDC File Offset: 0x0003CEDC
public override IEnumerator GetEnumerator()
{
return this.GetEnumerator(0, this.m_InnerCount);
}
// Token: 0x06000EC3 RID: 3779 RVA: 0x0003ECEC File Offset: 0x0003CEEC
public override IEnumerator GetEnumerator(int index, int count)
{
ArrayList.CheckRange(index, count, this.m_InnerCount);
return this.m_InnerArrayList.GetEnumerator(this.m_InnerIndex + index, count);
}
// Token: 0x06000EC4 RID: 3780 RVA: 0x0003ED10 File Offset: 0x0003CF10
public override void AddRange(ICollection c)
{
this.VerifyStateChanges();
this.m_InnerArrayList.InsertRange(this.m_InnerCount, c);
this.m_InnerCount += c.Count;
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000EC5 RID: 3781 RVA: 0x0003ED5C File Offset: 0x0003CF5C
public override int BinarySearch(object value)
{
return this.BinarySearch(0, this.m_InnerCount, value, Comparer.Default);
}
// Token: 0x06000EC6 RID: 3782 RVA: 0x0003ED74 File Offset: 0x0003CF74
public override int BinarySearch(object value, IComparer comparer)
{
return this.BinarySearch(0, this.m_InnerCount, value, comparer);
}
// Token: 0x06000EC7 RID: 3783 RVA: 0x0003ED88 File Offset: 0x0003CF88
public override int BinarySearch(int index, int count, object value, IComparer comparer)
{
ArrayList.CheckRange(index, count, this.m_InnerCount);
return this.m_InnerArrayList.BinarySearch(this.m_InnerIndex + index, count, value, comparer);
}
// Token: 0x06000EC8 RID: 3784 RVA: 0x0003EDBC File Offset: 0x0003CFBC
public override object Clone()
{
return new ArrayList.RangedArrayList((ArrayList)this.m_InnerArrayList.Clone(), this.m_InnerIndex, this.m_InnerCount);
}
// Token: 0x06000EC9 RID: 3785 RVA: 0x0003EDE0 File Offset: 0x0003CFE0
public override ArrayList GetRange(int index, int count)
{
ArrayList.CheckRange(index, count, this.m_InnerCount);
return new ArrayList.RangedArrayList(this, index, count);
}
// Token: 0x06000ECA RID: 3786 RVA: 0x0003EDF8 File Offset: 0x0003CFF8
public override void TrimToSize()
{
throw new NotSupportedException();
}
// Token: 0x06000ECB RID: 3787 RVA: 0x0003EE00 File Offset: 0x0003D000
public override void Sort()
{
this.Sort(Comparer.Default);
}
// Token: 0x06000ECC RID: 3788 RVA: 0x0003EE10 File Offset: 0x0003D010
public override void Sort(IComparer comparer)
{
this.Sort(0, this.m_InnerCount, comparer);
}
// Token: 0x06000ECD RID: 3789 RVA: 0x0003EE20 File Offset: 0x0003D020
public override void Sort(int index, int count, IComparer comparer)
{
this.VerifyStateChanges();
ArrayList.CheckRange(index, count, this.m_InnerCount);
this.m_InnerArrayList.Sort(this.m_InnerIndex + index, count, comparer);
this.m_InnerStateChanges = this.m_InnerArrayList._version;
}
// Token: 0x06000ECE RID: 3790 RVA: 0x0003EE68 File Offset: 0x0003D068
public override object[] ToArray()
{
object[] array = new object[this.m_InnerCount];
this.m_InnerArrayList.CopyTo(this.m_InnerIndex, array, 0, this.m_InnerCount);
return array;
}
// Token: 0x06000ECF RID: 3791 RVA: 0x0003EE9C File Offset: 0x0003D09C
public override Array ToArray(Type elementType)
{
Array array = Array.CreateInstance(elementType, this.m_InnerCount);
this.m_InnerArrayList.CopyTo(this.m_InnerIndex, array, 0, this.m_InnerCount);
return array;
}
// Token: 0x040003A4 RID: 932
private int m_InnerIndex;
// Token: 0x040003A5 RID: 933
private int m_InnerCount;
// Token: 0x040003A6 RID: 934
private int m_InnerStateChanges;
}
// Token: 0x0200011D RID: 285
[Serializable]
private sealed class SynchronizedListWrapper : ArrayList.ListWrapper
{
// Token: 0x06000ED0 RID: 3792 RVA: 0x0003EED0 File Offset: 0x0003D0D0
public SynchronizedListWrapper(IList innerList)
: base(innerList)
{
this.m_SyncRoot = innerList.SyncRoot;
}
// Token: 0x1700023E RID: 574
// (get) Token: 0x06000ED1 RID: 3793 RVA: 0x0003EEE8 File Offset: 0x0003D0E8
public override int Count
{
get
{
object syncRoot = this.m_SyncRoot;
int count;
lock (syncRoot)
{
count = this.m_InnerList.Count;
}
return count;
}
}
// Token: 0x1700023F RID: 575
// (get) Token: 0x06000ED2 RID: 3794 RVA: 0x0003EF3C File Offset: 0x0003D13C
public override bool IsSynchronized
{
get
{
return true;
}
}
// Token: 0x17000240 RID: 576
// (get) Token: 0x06000ED3 RID: 3795 RVA: 0x0003EF40 File Offset: 0x0003D140
public override object SyncRoot
{
get
{
object syncRoot = this.m_SyncRoot;
object syncRoot2;
lock (syncRoot)
{
syncRoot2 = this.m_InnerList.SyncRoot;
}
return syncRoot2;
}
}
// Token: 0x17000241 RID: 577
// (get) Token: 0x06000ED4 RID: 3796 RVA: 0x0003EF94 File Offset: 0x0003D194
public override bool IsFixedSize
{
get
{
object syncRoot = this.m_SyncRoot;
bool isFixedSize;
lock (syncRoot)
{
isFixedSize = this.m_InnerList.IsFixedSize;
}
return isFixedSize;
}
}
// Token: 0x17000242 RID: 578
// (get) Token: 0x06000ED5 RID: 3797 RVA: 0x0003EFE8 File Offset: 0x0003D1E8
public override bool IsReadOnly
{
get
{
object syncRoot = this.m_SyncRoot;
bool isReadOnly;
lock (syncRoot)
{
isReadOnly = this.m_InnerList.IsReadOnly;
}
return isReadOnly;
}
}
// Token: 0x17000243 RID: 579
public override object this[int index]
{
get
{
object syncRoot = this.m_SyncRoot;
object obj;
lock (syncRoot)
{
obj = this.m_InnerList[index];
}
return obj;
}
set
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerList[index] = value;
}
}
}
// Token: 0x06000ED8 RID: 3800 RVA: 0x0003F0E4 File Offset: 0x0003D2E4
public override int Add(object value)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerList.Add(value);
}
return num;
}
// Token: 0x06000ED9 RID: 3801 RVA: 0x0003F13C File Offset: 0x0003D33C
public override void Clear()
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerList.Clear();
}
}
// Token: 0x06000EDA RID: 3802 RVA: 0x0003F18C File Offset: 0x0003D38C
public override bool Contains(object value)
{
object syncRoot = this.m_SyncRoot;
bool flag;
lock (syncRoot)
{
flag = this.m_InnerList.Contains(value);
}
return flag;
}
// Token: 0x06000EDB RID: 3803 RVA: 0x0003F1E4 File Offset: 0x0003D3E4
public override int IndexOf(object value)
{
object syncRoot = this.m_SyncRoot;
int num;
lock (syncRoot)
{
num = this.m_InnerList.IndexOf(value);
}
return num;
}
// Token: 0x06000EDC RID: 3804 RVA: 0x0003F23C File Offset: 0x0003D43C
public override void Insert(int index, object value)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerList.Insert(index, value);
}
}
// Token: 0x06000EDD RID: 3805 RVA: 0x0003F28C File Offset: 0x0003D48C
public override void Remove(object value)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerList.Remove(value);
}
}
// Token: 0x06000EDE RID: 3806 RVA: 0x0003F2DC File Offset: 0x0003D4DC
public override void RemoveAt(int index)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerList.RemoveAt(index);
}
}
// Token: 0x06000EDF RID: 3807 RVA: 0x0003F32C File Offset: 0x0003D52C
public override void CopyTo(Array array, int index)
{
object syncRoot = this.m_SyncRoot;
lock (syncRoot)
{
this.m_InnerList.CopyTo(array, index);
}
}
// Token: 0x06000EE0 RID: 3808 RVA: 0x0003F37C File Offset: 0x0003D57C
public override IEnumerator GetEnumerator()
{
object syncRoot = this.m_SyncRoot;
IEnumerator enumerator;
lock (syncRoot)
{
enumerator = this.m_InnerList.GetEnumerator();
}
return enumerator;
}
// Token: 0x040003A7 RID: 935
private object m_SyncRoot;
}
// Token: 0x0200011E RID: 286
[Serializable]
private class FixedSizeListWrapper : ArrayList.ListWrapper
{
// Token: 0x06000EE1 RID: 3809 RVA: 0x0003F3D0 File Offset: 0x0003D5D0
public FixedSizeListWrapper(IList innerList)
: base(innerList)
{
}
// Token: 0x17000244 RID: 580
// (get) Token: 0x06000EE2 RID: 3810 RVA: 0x0003F3DC File Offset: 0x0003D5DC
protected virtual string ErrorMessage
{
get
{
return "List is fixed-size.";
}
}
// Token: 0x17000245 RID: 581
// (get) Token: 0x06000EE3 RID: 3811 RVA: 0x0003F3E4 File Offset: 0x0003D5E4
public override bool IsFixedSize
{
get
{
return true;
}
}
// Token: 0x06000EE4 RID: 3812 RVA: 0x0003F3E8 File Offset: 0x0003D5E8
public override int Add(object value)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EE5 RID: 3813 RVA: 0x0003F3F8 File Offset: 0x0003D5F8
public override void Clear()
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EE6 RID: 3814 RVA: 0x0003F408 File Offset: 0x0003D608
public override void Insert(int index, object value)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EE7 RID: 3815 RVA: 0x0003F418 File Offset: 0x0003D618
public override void Remove(object value)
{
throw new NotSupportedException(this.ErrorMessage);
}
// Token: 0x06000EE8 RID: 3816 RVA: 0x0003F428 File Offset: 0x0003D628
public override void RemoveAt(int index)
{
throw new NotSupportedException(this.ErrorMessage);
}
}
// Token: 0x0200011F RID: 287
[Serializable]
private sealed class ReadOnlyListWrapper : ArrayList.FixedSizeListWrapper
{
// Token: 0x06000EE9 RID: 3817 RVA: 0x0003F438 File Offset: 0x0003D638
public ReadOnlyListWrapper(IList innerList)
: base(innerList)
{
}
// Token: 0x17000246 RID: 582
// (get) Token: 0x06000EEA RID: 3818 RVA: 0x0003F444 File Offset: 0x0003D644
protected override string ErrorMessage
{
get
{
return "List is read-only.";
}
}
// Token: 0x17000247 RID: 583
// (get) Token: 0x06000EEB RID: 3819 RVA: 0x0003F44C File Offset: 0x0003D64C
public override bool IsReadOnly
{
get
{
return true;
}
}
// Token: 0x17000248 RID: 584
public override object this[int index]
{
get
{
return this.m_InnerList[index];
}
set
{
throw new NotSupportedException(this.ErrorMessage);
}
}
}
// Token: 0x02000120 RID: 288
[Serializable]
private class ListWrapper : IEnumerable, ICollection, IList
{
// Token: 0x06000EEE RID: 3822 RVA: 0x0003F470 File Offset: 0x0003D670
public ListWrapper(IList innerList)
{
this.m_InnerList = innerList;
}
// Token: 0x17000249 RID: 585
public virtual object this[int index]
{
get
{
return this.m_InnerList[index];
}
set
{
this.m_InnerList[index] = value;
}
}
// Token: 0x1700024A RID: 586
// (get) Token: 0x06000EF1 RID: 3825 RVA: 0x0003F4A0 File Offset: 0x0003D6A0
public virtual int Count
{
get
{
return this.m_InnerList.Count;
}
}
// Token: 0x1700024B RID: 587
// (get) Token: 0x06000EF2 RID: 3826 RVA: 0x0003F4B0 File Offset: 0x0003D6B0
public virtual bool IsSynchronized
{
get
{
return this.m_InnerList.IsSynchronized;
}
}
// Token: 0x1700024C RID: 588
// (get) Token: 0x06000EF3 RID: 3827 RVA: 0x0003F4C0 File Offset: 0x0003D6C0
public virtual object SyncRoot
{
get
{
return this.m_InnerList.SyncRoot;
}
}
// Token: 0x1700024D RID: 589
// (get) Token: 0x06000EF4 RID: 3828 RVA: 0x0003F4D0 File Offset: 0x0003D6D0
public virtual bool IsFixedSize
{
get
{
return this.m_InnerList.IsFixedSize;
}
}
// Token: 0x1700024E RID: 590
// (get) Token: 0x06000EF5 RID: 3829 RVA: 0x0003F4E0 File Offset: 0x0003D6E0
public virtual bool IsReadOnly
{
get
{
return this.m_InnerList.IsReadOnly;
}
}
// Token: 0x06000EF6 RID: 3830 RVA: 0x0003F4F0 File Offset: 0x0003D6F0
public virtual int Add(object value)
{
return this.m_InnerList.Add(value);
}
// Token: 0x06000EF7 RID: 3831 RVA: 0x0003F500 File Offset: 0x0003D700
public virtual void Clear()
{
this.m_InnerList.Clear();
}
// Token: 0x06000EF8 RID: 3832 RVA: 0x0003F510 File Offset: 0x0003D710
public virtual bool Contains(object value)
{
return this.m_InnerList.Contains(value);
}
// Token: 0x06000EF9 RID: 3833 RVA: 0x0003F520 File Offset: 0x0003D720
public virtual int IndexOf(object value)
{
return this.m_InnerList.IndexOf(value);
}
// Token: 0x06000EFA RID: 3834 RVA: 0x0003F530 File Offset: 0x0003D730
public virtual void Insert(int index, object value)
{
this.m_InnerList.Insert(index, value);
}
// Token: 0x06000EFB RID: 3835 RVA: 0x0003F540 File Offset: 0x0003D740
public virtual void Remove(object value)
{
this.m_InnerList.Remove(value);
}
// Token: 0x06000EFC RID: 3836 RVA: 0x0003F550 File Offset: 0x0003D750
public virtual void RemoveAt(int index)
{
this.m_InnerList.RemoveAt(index);
}
// Token: 0x06000EFD RID: 3837 RVA: 0x0003F560 File Offset: 0x0003D760
public virtual void CopyTo(Array array, int index)
{
this.m_InnerList.CopyTo(array, index);
}
// Token: 0x06000EFE RID: 3838 RVA: 0x0003F570 File Offset: 0x0003D770
public virtual IEnumerator GetEnumerator()
{
return this.m_InnerList.GetEnumerator();
}
// Token: 0x040003A8 RID: 936
protected IList m_InnerList;
}
}
}