#include <assert.h>            // DynamicArray.cpp
#include "DynamicArray.h"

// Remarque : pour acceder aux attributs et methodes de la classe
// de base AbstractArray<T>, il faut indiquer this->... pour y acceder !
// C'est a cause des templates !
// Exemple : this->_t
//
// On peut aussi ajouter AbstractArray<T>::
// Exemple : AbstractArray<T>::_t

// ............................................ DynamicArray<T> aDynamicArray;
// .................................. DynamicArray<T> aDynamicArray(capacity);
template <class T>
DynamicArray<T>::DynamicArray(int capacity)
: AbstractArray<T>(capacity)
{
 AbstractArray<T>::_t = new T[capacity];
 // for(int i = 0; i<AbstractArray<T>::_capacity; i++)
 // {
 //  AbstractArray<T>::_t[i] = T();
 // }
}

// ......................................... DynamicArray<T> aDynamicArray(a);
template <class T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& a)
: AbstractArray<T>(a)
{
 _copy(a);
}

// ................................................... aDynamicArray = a;
template <class T>
DynamicArray<T>& DynamicArray<T>::operator=(const DynamicArray<T>& a)
{
 if(this != &a) {
   AbstractArray<T>::operator=(a);
   _destroy();
   _copy(a);
 }
 return *this;
}

// ...................... DynamicArray<T> aDynamicArray(CArray,capacity);
template <class T>
DynamicArray<T>::DynamicArray(const T* CArray, int capacity)
: AbstractArray<T>(CArray,capacity)
{
 AbstractArray<T>::_t = new T[capacity];
 for(int i = 0; i < capacity; i++)
 {
  insert(CArray[i]);
 }
}

template <class T>
DynamicArray<T>::~DynamicArray(void)
{
 _destroy();
}

// ....................................... aDynamicArray.insert(element);
template <class T>
void DynamicArray<T>::insert(const T& element)
{
 if (AbstractArray<T>::full()) {
  _realloc(2*AbstractArray<T>::_capacity);
 }
 AbstractArray<T>::_t[AbstractArray<T>::_size++] = element;
}

// .................................................. aDynamicArray += a;
template <class T>
DynamicArray<T>& DynamicArray<T>::operator+=(const DynamicArray<T>& a)
{
 AbstractArray<T>::operator+=(a);
 return *this;
}

// ............................................................. a1 + a2;
template <class T>
DynamicArray<T> operator+(const DynamicArray<T>& a1,
                          const DynamicArray<T>& a2)
{
 DynamicArray<T> aDynamicArray(a1);
 return aDynamicArray += a2;
}

// ...................................................... _copy(a);
template <class T>
void DynamicArray<T>::_copy(const DynamicArray<T>& a)
{
 AbstractArray<T>::_t = new T[AbstractArray<T>::_capacity];
 for(int i = 0; i <a._size; i++)
 {
  AbstractArray<T>::_t[i] = a._t[i];
 }
}

// ................................................... _destroy();
template <class T>
void DynamicArray<T>::_destroy(void)
{
 if (AbstractArray<T>::_t) delete [] AbstractArray<T>::_t;
 AbstractArray<T>::_t = NULL;
}

// ....................................... _realloc(newCapacity);
template <class T>
void DynamicArray<T>::_realloc(int newCapacity)
{
 if (AbstractArray<T>::_capacity == newCapacity) return;
 T* newt = new T[newCapacity];
 int limit = AbstractArray<T>::_size < newCapacity ?
                               AbstractArray<T>::_size : newCapacity;
 for(int i = 0; i < limit; i++)
 {
  newt[i] = AbstractArray<T>::_t[i];
 }
 _destroy();
 AbstractArray<T>::_size = limit;
 AbstractArray<T>::_capacity = newCapacity;
 AbstractArray<T>::_t = newt;
}