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

// ............................................. Array<T> anArray;
// .................................. Array<T> anArray(capacity);
template <class T>
Array<T>::Array(int capacity)
: _size(0), _capacity(capacity), _t(new T[capacity])
{
 // for(int i = 0; i<_capacity; i++) _t[i] = T();
}

// .......................................... Array<T> anArray(a);
template <class T>
Array<T>::Array(const Array<T>& a)
{
 _copy(a);
}

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

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

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

// ..................................... T* CArray = (T*)anArray;
template <class T>
Array<T>::operator T*(void)
{
 return _t;
}

// ................................................ anArray.size();
template <class T>
int Array<T>::size(void) const
{
 return _size;
}

// ........................................... anArray.capacity();
template <class T>
int Array<T>::capacity(void) const
{
 return _capacity;
}

// .............................................. anArray.empty();
template <class T>
bool Array<T>::empty(void) const
{
 return _size == 0;
}

// ................................................ anArray.full();
template <class T>
bool Array<T>::full(void) const
{
 return _size == _capacity;
}

// ......................................... anArray.has(element);
template <class T> 
int Array<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;
}

// ...................... anArray[index] pour un Array non constant
template <class T>
T& Array<T>::operator[](int index)
{
 assert(index >= 0 && index <_size);
 return _t[index];
}

// ...................... anArray[index]; pour un Array constant !!
template <class T>
const T& Array<T>::operator[](int index) const
{
 assert(index >= 0 && index <_size);
 return _t[index];
}

// .................................................. anArray == a;
template <class T>
bool Array<T>::operator==(const Array<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;
}

// .................................................. anArray != a;
template <class T>
bool Array<T>::operator!=(const Array<T>& a) const
{
 return !operator==(a);
}

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

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

// ........................................... anArray << element;
template <class T>
Array<T>& Array<T>::operator<<(const T& element)
{
 insert(element);
 return *this;
}

// ........................................... anArray >> element;
template <class T>
Array<T>& Array<T>::operator>>(T& element)
{
 element = remove();
 return *this;
}

// .................................................. anArray(t,f);
template <class T>
T Array<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;
}

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

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

// ......................................................... s << a;
template <class T>
ostream& operator<<(ostream& s, const Array<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 << ')';
}

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

// ................................................... _destroy();
template <class T>
void Array<T>::_destroy(void)
{
 if (_t) delete [] _t;
 _size = 0;
 _capacity = 0;
 _t = NULL;
}

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