List

list.cpp

#pragma once

template<class T>
class List
{
private:
	int bufferSize,top,sizeCap;
public:
	T* buffer;

	//void func ( void (*f)(int) );

	int Contains(T value)
	{
		if(buffer != NULL && top > 0)
		{
			for(int i = 0; i < top;i++)
			{
				if(buffer[i] == value)
					return true;
			}
		}
		return false;
	}

	int IndexOf(T value)
	{
		if(buffer != NULL && top > 0)
		{
			for(int i = 0; i < top;i++)
			{
				if(buffer[i] == value)
					return i;
			}
		}
		return -1;
	}

	void ForEach(void (*f)(T,int))
	{
		if(buffer != NULL && top > 0)
		{
			for(int i = 0; i < top; i++)
			{
				f(buffer[i],i);
			}
		}
	}

	int MemorySize()
	{
		return bufferSize * sizeof(T);
	}

	int Count()
	{
		if(buffer != NULL)
			return top;
		return 0;
	}

	int Capacity()
	{
		if(sizeCap > 0)
			return sizeCap;
		return -1;
	}

	List(int size = 32,int cap = 0)
	{
		sizeCap = cap;
		if(size > 0)
		{
			buffer = new T[size];
			bufferSize = size;
		}
		else
		{
			buffer = new T[1];
			bufferSize = 1;
		}
		top = 0;
	}

	void Init(int size = 32,int cap = 0)
	{
		sizeCap = cap;
		if(size > 0)
		{
			buffer = new T[size];
			bufferSize = size;
		}
		else
		{
			buffer = new T[1];
			bufferSize = 1;
		}
		top = 0;
	}

	void Clear()
	{
		top = 0;
	}

	~List()
	{
		Release(false);
	}

	void Release(int del = false)
	{
		if(del)
		{
			delete this;
		}
		else if(buffer)
		{
			delete buffer;
			buffer = NULL;
		}
	}

	void Push(const T & item)
	{
		Add(item);
	}

	T Pop()
	{
		return Grab(top-1);
	}

	T Dequeue()
	{
		return Grab(0);
	}

	void Enqueue(const T & item)
	{
		Add(item);
	}

	void Insert(const T & item, int i)
	{
		if(i == top)
			Add(item);
		else if(i < top && i >= 0)
		{
			memcpy(&buffer[i+1],&buffer[i],(top - i) * sizeof(T));
			buffer[i] = item;
			top++;
			if(top >= bufferSize)
			{
				int newSize = bufferSize * 2;
				T* newBuff = new T[newSize];
				memcpy(newBuff,buffer,newSize * sizeof(T));
				delete buffer;
				buffer = newBuff;
				bufferSize = newSize;
			}
		}
	}

	void Add(const T & item)
	{
		if(sizeCap <= 0 || (top < sizeCap))
		{
			buffer[top] = item;
			top++;
			if(top >= bufferSize)
			{
				int newSize = bufferSize * 2;
				T* newBuff = new T[newSize];
				memcpy(newBuff,buffer,newSize * sizeof(T));
				delete buffer;
				buffer = newBuff;
				bufferSize = newSize;
			}
		}
	}

	void Remove(int i)
	{
		if(buffer != NULL)
		{
			if(i < top && i >= 0)
			{
				int ntop = top - 1;
				int cpyCount = ntop - i;
				if(cpyCount > 0)
				{
					int cpyStart = i + 1;
					void* memLoc = &buffer[i];
					void* memSrc = &buffer[cpyStart];
					memcpy(memLoc,memSrc,cpyCount * sizeof(T));
				}
				top--;
			}
		}
	}

	int TryRemove(T value)
	{
		int i = IndexOf(value);
		if(i != -1)
		{
			Remove(i);
			return true;
		}
		return false;
	}

	T& operator[](int i)
	{
		if(buffer && i < top && i >= 0)
		{
			return buffer[i];
		}
	}

	T Grab(int i)
	{
		if(buffer)
		{
			if(i < top && i >= 0)
			{
				T result = buffer[i];
				Remove(i);
				return result;
			}
		}
	}
};