List from ListCore

using System; using System.Collections; using System.Collections.Generic;
using System.ComponentModel; namespace Fire {
//##################################################################################################
[XmlProps(""), Props("")]
public partial class FireList<T>: ListCore<T>, IFireList<T>, IFireList, IClearable {
public FireList() { }
public FireList(int capacity) : base(capacity) { }
public FireList(ICollection<T> src) : base(src) { }
public FireList(IEnumerable<T> src) : base(src) { }
public FireList(IEnumerable src) : base(src) { }
public FireList(T[] src, bool swallow) : base(src, swallow) { }
public FireList(T[] src, int from) : base(src, from) { }
public FireList(T[] src, int from, int count) : base(src, from, count) { }
//------------------------------------------------------------------------------------------
public void EnsureCapacity(int min) { EnsureCapacityCore(min); }
public void Grow() { GrowCore(); }
public int Capacity { get { return items.Length; } set { CapacityCore = value; } }
public int Count { get { return size; } set { CountCore = value; } }
//------------------------------------------------------------------------------------------
public T this[int index] { get { return GetCore(index); } set { SetCore(index, value); } }
public IEnumerator<T> GetEnumerator() { return GetEnumeratorCore(); }
//------------------------------------------------------------------------------------------
public void Add(T item) { AddCore(item); }
public void Insert(int index, T item) { InsertCore(index, item); }
public T TryAdd(T item) { return TryAddCore(item); }
public void AddRange(T[] a) { AddRangeCore(a); }
public void InsertRange(int index, T[] a) { InsertRange(index, a); }
public void AddRange(ICollection<T> src) { AddRangeCore(src); }
public void InsertRange(int index, ICollection<T> src) { InsertRangeCore(index, src); }
public void AddRange2(ICollection src) { AddRangeCore2(src); }
public void InsertRange2(int index, ICollection src) { InsertRangeCore2(index, src); }
public void AddRange(T[] src, int from) { AddRangeCore(src, from); }
public void InsertRange(int index, T[] src, int from) { InsertRangeCore(index, src, from); }
public void AddRange(T[] src, int from, int count) { AddRangeCore(src, from, count); }
public void InsertRange(int index, T[] src, int from, int count) { InsertRangeCore(index, src, from, count); }
//------------------------------------------------------------------------------------------
public void Clear() { ClearCore(); }
public bool Remove(T item) { return RemoveCore(item); }
public void RemoveAt(int index) { RemoveAtCore(index); }
public void RemoveRange(int from, int count) { RemoveRangeCore(from, count); }
//------------------------------------------------------------------------------------------
public T Move(int from, int to) { return MoveCore(from, to); }
public int SetIndex(T item, int to) { return SetIndexCore(item, to); }
public int MoveRelative(T item, int move) { return MoveRelativeCore(item, move); }
public void Swap(int a, int b) { SwapCore(a, b); }
//------------------------------------------------------------------------------------------
public bool Contains(T item) { return ContainsCore(item); }
//------------------------------------------------------------------------------------------
public int IndexOf(T item) { return IndexOfCore(item); }
public int IndexOf(T item, int startIndex) { return IndexOfCore(item, startIndex); }
public int IndexOf(T item, int startIndex, int count) { return IndexOfCore(item, startIndex, count); }
//------------------------------------------------------------------------------------------
public int LastIndexOf(T item) { return LastIndexOfCore(item); }
public int LastIndexOf(T item, int startIndex) { return LastIndexOfCore(item, startIndex); }
public int LastIndexOf(T item, int startIndex, int count) { return LastIndexOfCore(item, startIndex, count); }
//------------------------------------------------------------------------------------------
public void CopyTo(T[] array) { CopyToCore(array); }
public void CopyTo(T[] array, int index) { CopyToCore(array, index); }
public void CopyTo(Array array) { CopyToCore(array); }
public void CopyTo(Array array, int index) { CopyToCore(array, index); }
public T[] ToArray() { T[] array = new T[Count]; CopyToCore(array); return array; }
public T[] SubArray(int from, int count) { return SubArrayCore(from, count); }
//------------------------------------------------------------------------------------------
public void Sort() { SortCore(); }
public void Sort(IComparer<T> cmp) { SortCore(cmp); }
public void Sort(int from, int count) { SortCore(from, count); }
public void Sort(int from, int count, IComparer<T> cmp) { SortCore(from, count, cmp); }
//------------------------------------------------------------------------------------------
public void Reverse() { ReverseCore(); }
//------------------------------------------------------------------------------------------
IEnumerator IEnumerable.GetEnumerator() { return GetEnumeratorCore(); }
bool ICollection.IsSynchronized { get { return false; } }
object ICollection.SyncRoot { get { return this; } }
bool IList.IsFixedSize { get { return false; } }
bool IList.IsReadOnly { get { return false; } }
bool ICollection<T>.IsReadOnly { get { return false; } }
//------------------------------------------------------------------------------------------
int IList.Add(object item) { Verify(item); int i = size; Add((T)item); return i; }
bool IList.Contains(object item) { return IsGood(item) && Contains((T)item); }
int IList.IndexOf(object item) { return IsGood(item) ? IndexOf((T)item) : -1; }
void IList.Insert(int index, object item) { Verify(item); Insert(index, (T)item); }
void IList.Remove(object item) { if(IsGood(item)) Remove((T)item); }
//------------------------------------------------------------------------------------------
object IList.this[int index] {
    get { return GetCore(index); }
    set { Verify(value); this[index] = (T)value; } }
//------------------------------------------------------------------------------------------
void IFireList.Sort(IComparer cmp) { items.Sort(0, size, cmp); }
object IFireList.Move(int from, int to) { return Move(from, to); }
//##################################################################################################
}}