#ifndef _HEADER_H_
#define _HEADER_H_

template <typename T>
class DynamicArray {
    T *container;
    unsigned alloc_size;
    unsigned arr_size;
    void copy(const DynamicArray&);
    static T error;
public:
    DynamicArray();
    ~DynamicArray();
    DynamicArray(const DynamicArray&);
    DynamicArray& operator=(const DynamicArray&);

/// ////////////////////////
    T &at(unsigned int);
    void add(const T&);

    bool del(unsigned int);
    unsigned int size();
};

template <typename T>
T DynamicArray<T>::error;

template <typename T>
DynamicArray<T>::DynamicArray()
{
    arr_size = 0;
    alloc_size = 4;
    container = new T[alloc_size];
}

template <typename T>
DynamicArray<T>::~DynamicArray()
{
    delete[] container;
}

template <typename T>
void DynamicArray<T>::add(const T &d)
{
    container[arr_size++] = d;

    if (arr_size >= alloc_size) {
        T *tmp = new T [(alloc_size *= 2)];
        int cc = 0;

        while (cc < arr_size)
            tmp[cc] = container[cc++];

        delete[] container;
        container = tmp;
    }
}

template <typename T>
void DynamicArray<T>::copy(const DynamicArray& other)
{
    alloc_size = other.alloc_size;
    arr_size = other.arr_size;
    container = new T[alloc_size];
    for(int i = 0 ; i < arr_size ; i++) {
        container[i] = other.container[i];
    }
}

template <typename T>
T& DynamicArray<T>::at(unsigned index)
{
    if (index > arr_size)
        return error; // FIXME

    return container[index];
}

template <typename T>
unsigned int DynamicArray<T>::size()
{
	return arr_size;
}

template <typename T>
bool DynamicArray<T>::del(unsigned int index)
{
    if(index<arr_size) {
	    while (index < arr_size - 1) {
	    	container[index] = container[++index];
	    }
	    --arr_size;
	    return true;
	}
	else return false;
}

template <typename T>
DynamicArray<T>::DynamicArray(const DynamicArray& other)
{
    copy(other);
}

template <typename T>
DynamicArray<T>& DynamicArray<T>::operator=(const DynamicArray& other)
{
    if(this != &other) {
        delete[] container;
        copy(other);
    }
    return *this;
}


#endif