#include <assert.h>              // Fichier Stack.cpp
#include "Stack.h"

template <class T>
Stack<T>::Stack(void) : _size(0) {}

template <class T>
Stack<T>::Stack(const Stack<T>& s)
{
 _copy(s);
}

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

template <class T>
Stack<T>::~Stack(void) {}

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

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

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

template <class T>
const T& Stack<T>::top(void) const {
 assert(!empty());
 return _stack[_size - 1];
}

template <class T>
void Stack<T>::push(const T& t) {
 assert(!full());
 _stack[_size++] = t;
}

template <class T>
T Stack<T>::pop(void) {
 assert(!empty());
 return _stack[--_size];
}

template <class T>
void Stack<T>::_copy(const Stack<T>& s)
{
 _size = s._size;
 for(int i=0; i< _size; i++)
 {
  _stack[i] = s._stack[i];
 }
}

template <class T>
void Stack<T>::_destroy(void)
{
}

template <class T>
ostream& operator<<(ostream& os, const Stack<T>& s)
{
 os << endl ;
 os << " Une Stack<T> :" << endl; 
 for(int i=s._size-1; i>=0; i--)
 {
  if (s._size==1)   os << "sommet & fond : ";
  else
  if (i==s._size-1) os << "       sommet : ";
  else
  if (i==0)         os << "         fond : ";
  else              os << "                ";

  os << s._stack[i];

  os << endl;
 }
 os << "~~~~~~~~~~~~~~~" << endl;

 return os;
}