166 lines
3.2 KiB
C#
166 lines
3.2 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Obi
|
|
{
|
|
/**
|
|
* Custom IList implementation that allows access to the underlying raw array, for efficient C++ interop. Also
|
|
* includes some auxiliar methods that make it easier and faster to send data back and forth between C# and C++, as
|
|
* well as deal with accesing the contents of the list directly without a copy.
|
|
*/
|
|
public class ObiList<T> : IList<T>
|
|
{
|
|
private T[] data = new T[16];
|
|
private int count = 0;
|
|
|
|
#region Implementation of IEnumerable
|
|
|
|
public IEnumerator<T> GetEnumerator()
|
|
{
|
|
for (int i = 0; i < count;++i)
|
|
yield return data[i];
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator()
|
|
{
|
|
return GetEnumerator();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Implementation of ICollection<T>
|
|
|
|
public void Add(T item)
|
|
{
|
|
EnsureCapacity(count + 1);
|
|
data[count++] = item;
|
|
}
|
|
|
|
public void Clear()
|
|
{
|
|
count = 0;
|
|
}
|
|
|
|
public bool Contains(T item)
|
|
{
|
|
for (int i = 0; i < count; ++i)
|
|
if (data[i].Equals(item))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public void CopyTo(T[] array, int arrayIndex)
|
|
{
|
|
if (array == null)
|
|
throw new ArgumentNullException();
|
|
|
|
if (array.Length-arrayIndex < count)
|
|
throw new ArgumentException();
|
|
|
|
Array.Copy(data,0,array,arrayIndex,count);
|
|
}
|
|
|
|
public bool Remove(T item)
|
|
{
|
|
bool found = false;
|
|
for (int i = 0; i < count; ++i)
|
|
{
|
|
// Look for the element, and mark it as found.
|
|
if (!found && data[i].Equals(item))
|
|
found = true;
|
|
|
|
//If we found the element and are not at the last element, displace the element 1 position backwards.
|
|
if (found && i < count-1)
|
|
{
|
|
data[i] = data[i+1];
|
|
}
|
|
}
|
|
|
|
// If we found and removed the element, reduce the element count by 1.
|
|
if (found)
|
|
count--;
|
|
|
|
return found;
|
|
}
|
|
|
|
public int Count
|
|
{
|
|
get { return count; }
|
|
}
|
|
|
|
public bool IsReadOnly
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Implementation of IList<T>
|
|
|
|
public int IndexOf(T item)
|
|
{
|
|
return Array.IndexOf(data,item);
|
|
}
|
|
|
|
public void Insert(int index, T item)
|
|
{
|
|
if (index < 0 || index > count)
|
|
throw new ArgumentOutOfRangeException();
|
|
|
|
EnsureCapacity(++count);
|
|
|
|
for (int i = count-1; i > index; ++i)
|
|
{
|
|
data[i] = data[i-1];
|
|
}
|
|
|
|
data[index] = item;
|
|
}
|
|
|
|
public void RemoveAt(int index)
|
|
{
|
|
for (int i = index; i < count; ++i)
|
|
{
|
|
if (i < count-1)
|
|
{
|
|
data[i] = data[i+1];
|
|
}
|
|
}
|
|
|
|
count--;
|
|
}
|
|
|
|
public T this[int index]
|
|
{
|
|
get { return data[index]; }
|
|
set { data[index] = value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Added stuff
|
|
|
|
public T[] Data{
|
|
get{return data;}
|
|
}
|
|
|
|
/**
|
|
* Ensures a minimal capacity of count elements, then sets the new count. Useful when passing the backing array to C++
|
|
* for being filled with new data.
|
|
*/
|
|
public void SetCount(int count){
|
|
EnsureCapacity(count);
|
|
this.count = count;
|
|
}
|
|
|
|
public void EnsureCapacity(int capacity){
|
|
if (capacity >= data.Length)
|
|
Array.Resize(ref data,capacity*2);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|
|
|