#ifndef _INCLUDE_KNIGHT_KE_VECTOR_H_

#define _INCLUDE_KNIGHT_KE_VECTOR_H_

#include <new>

namespace Knight

{

	template <class T>

	class KeVector

	{

	public:

		KeVector<T>() : m_Data(NULL), m_Size(0), m_CurrentUsedSize(0)

		{

		}

		KeVector<T>(const KeVector<T> & other)

		{

			m_Size = other.m_CurrentUsedSize;

			m_CurrentUsedSize = other.m_CurrentUsedSize;

			if (m_Size > 0)

			{

				m_Data = new T[other.m_CurrentUsedSize];

				for (size_t i = 0; i < m_Size; i++)

				{

					m_Data[i] = other.m_Data[i];

				}

			}

			else

			{

				m_Data = NULL;

			}

		}

		~KeVector<T>()

		{

			clear();

		}

		KeVector & operator =(const KeVector<T> & other)

		{

			clear();

			if (other.m_CurrentUsedSize)

			{

				m_Data = new T[other.m_CurrentUsedSize];

				m_Size = other.m_CurrentUsedSize;

				m_CurrentUsedSize = other.m_CurrentUsedSize;

				for (size_t i = 0; i < m_Size; i++)

				{

					m_Data[i] = other.m_Data[i];

				}

			}

		}

		size_t size() const

		{

			return m_CurrentUsedSize;

		}

		void push_back(const T & elem)

		{

			GrowIfNeeded(1);

			new (&m_Data[m_CurrentUsedSize]) T(elem);

			m_CurrentUsedSize++;

		}

		void pop_back(const T & elem)

		{

			if (m_CurrentUsedSize == 0)

			{

				return;

			}

			m_CurrentUsedSize--;

			m_Data[m_CurrentUsedSize].~T();

		}

		bool is_empty()

		{

			return (m_CurrentUsedSize == 0);

		}

		T & operator [](size_t pos)

		{

			return m_Data[pos];

		}

		const T & operator [](size_t pos) const

		{

			return m_Data[pos];

		}

		void clear()

		{

			for (size_t i = 0; i < m_CurrentUsedSize; i++)

			{

				m_Data[i].~T();

			}

			free(m_Data);

			m_Data = NULL;

			m_Size = 0;

			m_CurrentUsedSize = 0;

		}

	private:

		void Grow(size_t amount)

		{

			T *new_data;

			size_t new_size;

			if (m_Size == 0)

			{

				new_size = 8;

			}

			else

			{

				new_size = m_Size * 2;

			}

			while (m_CurrentUsedSize + amount > new_size)

			{

				new_size *= 2;

			}

			new_data = (T *)malloc(sizeof(T) * new_size);

			for (size_t i = 0; i < m_CurrentUsedSize; i++)

			{

				new (&new_data[i]) T(m_Data[i]);

				m_Data[i].~T();

			}

			free(m_Data);

			m_Data = new_data;

			m_Size = new_size;

		}

		void GrowIfNeeded(size_t amount)

		{

			if (m_CurrentUsedSize + amount >= m_Size)

			{

				Grow(amount);

			}

		}

	private:

		T *m_Data;

		size_t m_Size;

		size_t m_CurrentUsedSize;

	};

}

#endif //_INCLUDE_KNIGHT_KE_VECTOR_H_