public static int Copy <T>(T[] source, int sourceOffset, MarshalArrayBase destination, int destOffset, int count)
{
if (sourceOffset < 0 || destOffset < 0 || count < 0)
{
throw new ArgumentException("sourceOffset < 0 or destOffset < 0 or count < 0");
}
if (source.Length - sourceOffset < count)
{
count = source.Length - sourceOffset;
}
if (destination.Length - destOffset < count)
{
count = destination.Length - destOffset;
}
int srcIndex = sourceOffset;
int dstIndex = destOffset;
int srcEnd = sourceOffset + count;
while (srcIndex < srcEnd)
{
destination.SetValue <T>(dstIndex, source[srcIndex]);
++dstIndex;
++srcIndex;
}
return(count);
}
public static int LastIndexOf <T>(MarshalArrayBase source, T item, int beginIndex, int count)
{
if (beginIndex < 0 || count < 0)
{
throw new ArgumentException("beginIndex < 0 or count < 0");
}
if (beginIndex >= source.Length)
{
beginIndex = source.Length - 1;
}
if (beginIndex + 1 < count)
{
count = beginIndex + 1;
}
int end = beginIndex - count;
int i = beginIndex;
while (i > end)
{
if (source.GetValue <T>(i).Equals(item))
{
return(i);
}
--i;
}
return(-1);
}
public void CopyTo(int index, MarshalArray <T> array, int arrayIndex, int count)
{
if (this.m_size - index < count)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
}
MarshalArrayBase.Copy(this.m_items, index, array, arrayIndex, count);
}
public int IndexOf(T item, int index)
{
if (index > this.m_size)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
}
return(MarshalArrayBase.IndexOf <T>(this.m_items, item, index, this.m_size - index));
}
public void RemoveAt(int index)
{
if ((uint)index >= (uint)this.m_size)
{
ThrowHelper.ThrowArgumentOutOfRangeException();
}
--this.m_size;
if (index < this.m_size)
{
MarshalArrayBase.Copy(this.m_items, index + 1, this.m_items, index, this.m_size - index);
}
this.m_items[this.m_size] = default(T);
++this.m_version;
}
public int LastIndexOf(T item, int index, int count)
{
if (this.m_size == 0)
{
return(-1);
}
if (index < 0 || count < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(index < 0 ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
}
if (index >= this.m_size || count > index + 1)
{
ThrowHelper.ThrowArgumentOutOfRangeException(index >= this.m_size ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_BiggerThanCollection);
}
return(MarshalArrayBase.LastIndexOf <T>(this.m_items, item, index, count));
}
public void InsertRange(int index, IEnumerable <T> collection)
{
if (collection == null)
{
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
}
if ((uint)index > (uint)this.m_size)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index);
}
ICollection <T> objs = collection as ICollection <T>;
if (objs != null)
{
int count = objs.Count;
if (count > 0)
{
this.EnsureCapacity(this.m_size + count);
if (index < this.m_size)
{
MarshalArrayBase.Copy(this.m_items, index, this.m_items, index + count, this.m_size - index);
}
if (this == objs)
{
MarshalArrayBase.Copy(this.m_items, 0, this.m_items, index, index);
MarshalArrayBase.Copy(this.m_items, index + count, this.m_items, index * 2, this.m_size - index);
}
else
{
T[] array = new T[count];
objs.CopyTo(array, 0);
MarshalArrayBase.Copy <T>(array, 0, m_items, index, count);
}
this.m_size += count;
}
}
else
{
foreach (T obj in collection)
{
this.Insert(index++, obj);
}
}
++this.m_version;
}
public void Insert(int index, T item)
{
if ((uint)index > (uint)this.m_size)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_ListInsert);
}
if (this.m_size == this.m_items.Length)
{
this.EnsureCapacity(this.m_size + 1);
}
if (index < this.m_size)
{
MarshalArrayBase.Copy(this.m_items, index, this.m_items, index + 1, this.m_size - index);
}
this.m_items[index] = item;
++this.m_size;
++this.m_version;
}
public MarshalList <T> GetRange(int index, int count)
{
if (index < 0 || count < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(
index < 0 ? ExceptionArgument.index : ExceptionArgument.count,
ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
}
if (this.m_size - index < count)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
}
MarshalList <T> objList = new MarshalList <T>(count);
MarshalArrayBase.Copy(this.m_items, index, objList.m_items, 0, count);
objList.m_size = count;
return(objList);
}
public unsafe static int Copy(MarshalArrayBase source, int sourceOffset, MarshalArrayBase destination, int destOffset, int count)
{
if (sourceOffset < 0 || destOffset < 0 || count < 0)
{
throw new ArgumentException("sourceOffset < 0 or destOffset < 0 or count < 0");
}
if (source.Length - sourceOffset < count)
{
count = source.Length - sourceOffset;
}
if (destination.Length - destOffset < count)
{
count = destination.Length - destOffset;
}
return(CopyBytes(source.Ptr, source.m_elementSize * sourceOffset,
destination.Ptr, destination.m_elementSize * destOffset,
source.m_elementSize * count));
}
public void RemoveRange(int index, int count)
{
if (index < 0 || count < 0)
{
ThrowHelper.ThrowArgumentOutOfRangeException(index < 0 ? ExceptionArgument.index : ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum);
}
if (this.m_size - index < count)
{
ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen);
}
if (count <= 0)
{
return;
}
this.m_size -= count;
if (index < this.m_size)
{
MarshalArrayBase.Copy(this.m_items, index + count, this.m_items, index, this.m_size - index);
}
//MarshalArrayBase.Clear(this.m_items, this.m_size, count);
++this.m_version;
}
public int IndexOf(T item)
{
return(MarshalArrayBase.IndexOf <T>(this.m_items, item, 0, this.m_size));
}
public void CopyTo(MarshalArray <T> array, int arrayIndex)
{
MarshalArrayBase.Copy(this.m_items, 0, array, arrayIndex, this.m_size);
}
public void CopyTo(Array array, int index)
{
MarshalArrayBase.Copy(this.m_items, 0, (T[])array, index, this.m_size);
}
public T[] ToArray()
{
T[] objArray = new T[this.m_size];
MarshalArrayBase.Copy(this.m_items, 0, objArray, 0, this.m_size);
return(objArray);
}