#include <assert.h>            // StaticArray.cpp
#include "StaticArray.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

// ............................................ StaticArray<T> aStaticArray;
// .................................. StaticArray<T> aStaticArray(capacity);
template <class T>
StaticArray<T>::StaticArray(void)
: AbstractArray<T>(MAX)
{
 AbstractArray<T>::_t = _st;
 for(int i = 0; i<AbstractArray<T>::_capacity; i++)
 {
   AbstractArray<T>::_t[i] = T();
 }
}

// ......................................... StaticArray<T> aStaticArray(a);
template <class T>
StaticArray<T>::StaticArray(const StaticArray<T>& a)
: AbstractArray<T>(a)
{
 AbstractArray<T>::_t = _st;
 _copy(a);
}

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

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

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

// ....................................... aStaticArray.insert(element);
template <class T>
void StaticArray<T>::insert(const T& element)
{
 assert(!AbstractArray<T>::full());
 AbstractArray<T>::_t[AbstractArray<T>::_size++] = element;
}

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

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

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

// ................................................... _destroy();
template <class T>
void StaticArray<T>::_destroy(void)
{
 AbstractArray<T>::_t = NULL;
}