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

template <class T>
AbstractArray<T>::AbstractArray(int capacity)
: _size(0), _capacity(capacity), _t(NULL)
{
 // L'allocation/affectation du pointeur _t
 // est a la charge des classes derivees !
}

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

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

template <class T>
AbstractArray<T>::AbstractArray(const T* CArray, int capacity)
: _size(0), _capacity(capacity), _t(NULL)
{
 // L'allocation/affectation du pointeur _t
 // est a la charge des classes derivees !
 // 
 // Et la boucle suivante aussi.
 // En effet, le tableau n'existe reellement que lorsque le
 // constructeur de la classe derivee a ete execute ...
 // ... Et donc apres l'appel du present constructeur !
 //
 // for(int i = 0; i < capacity; i++)
 // {
 //  insert(CArray[i]);
 // }
 
 (void)CArray;
}

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

template <class T>
AbstractArray<T>::operator T*(void)
{
 return _t;
}

template <class T>
int AbstractArray<T>::size(void) const
{
 return _size;
}

template <class T>
int AbstractArray<T>::capacity(void) const
{
 return _capacity;
}

template <class T>
bool AbstractArray<T>::empty(void) const
{
 return _size == 0;
}

template <class T>
bool AbstractArray<T>::full(void) const
{
 return _size == _capacity;
}

template <class T> 
int AbstractArray<T>::has(const T& element) const // retourne l’index ou -1
{
 for(int i = 0; i <_size; i++)
 {
  if (_t[i] == element) return i;
 }
 return -1;
}

template <class T>
T& AbstractArray<T>::operator[](int index)
{
 assert(index >= 0 && index <_size);
 return _t[index];
}

template <class T>
const T& AbstractArray<T>::operator[](int index) const
{
 assert(index >= 0 && index <_size);
 return _t[index];
}

template <class T>
bool AbstractArray<T>::operator==(const AbstractArray<T>& a) const
{
 if(_size != a._size) return false;
 if(_capacity != a._capacity) return false;
 for(int i = 0; i <_size; i++)
 {
  if (_t[i] != a._t[i]) return false;
 }
 return true;
}

template <class T>
bool AbstractArray<T>::operator!=(const AbstractArray<T>& a) const
{
 return !operator==(a);
}

template <class T>
AbstractArray<T>& AbstractArray<T>::operator+=(const AbstractArray<T>& a)
{
 for(int i = 0; i < a._size ; i++)
 {
  insert(a._t[i]);
 }
 return *this;
}

template <class T>
AbstractArray<T>& AbstractArray<T>::operator<<(const T& element)
{
 insert(element);
 return *this;
}

template <class T>
AbstractArray<T>& AbstractArray<T>::operator>>(T& element)
{
 element = remove();
 return *this;
}

template <class T>
T AbstractArray<T>::operator()(const T& t, T (*f)(const T&,const T&)) const
{
 T result = t;
 for(int i = 0; i <_size; i++)
 {
  result = f(result,_t[i]);
 }
 return result;
}

template <class T>
T AbstractArray<T>::remove(void)
{
 assert(!empty());
 return _t[--_size];
} 

template <class T>
void AbstractArray<T>::_copy(const AbstractArray<T>& a)
{
 _size = a._size;
 _capacity = a._capacity;
}

template <class T>
void AbstractArray<T>::_destroy(void)
{
 this->_size = 0;
 this->_capacity = 0;
 this->_t = NULL;
}

template <class T>
ostream& operator<<(ostream& s, const AbstractArray<T>& a)
{
 s << '(';
 if (!a.empty()) {
   for(int i = 0; i < a._size - 1; i++)
   {
    s << a._t[i] << ',';
   }
   s << a._t[a._size - 1];
 }
 return s << ')';
}