// IG17 2004-05, II17 2005-06
// Pila.cpp
// 17-12-2004

#include <iostream>
using namespace std;

#include "Pila.h"

template <class T>
Pila<T>::Nodo::Nodo(const T & d, Nodo *s) : dato(d), sig(s) {
}

template <class T>
Pila<T>::Pila() : datos(NULL), talla(0) {
}

template <class T>
Pila<T>::Pila (const Pila<T> & p) : datos(NULL), talla(0) {
  *this = p;
}

template <class T>
Pila<T> & Pila<T>::operator= (const Pila<T> &p) {
  if (this != &p) {
    Nodo *anterior;
    Vaciar();
    talla = p.talla;
    for (Nodo *aux = p.datos; aux != NULL; aux = aux->sig) {
      Nodo *nuevo = new Nodo(aux->dato);
      if (datos == NULL)
	anterior = datos = nuevo;
      else
	anterior = anterior->sig = nuevo;
    }
  }
  return *this;
}

template <class T>
Pila<T>::~Pila(){
  Vaciar();
}

template <class T>
void Pila<T>::Ver() const {
  cout << "[";
  for (Nodo *aux = datos; aux != NULL; aux = aux->sig) {
    cout << aux->dato;
    if (aux->sig != NULL) cout << ",";
  }
  cout << "] (talla = " << talla << ")" << endl;
}

template <class T>
void Pila<T>::Apilar(const T & d) {
  datos = new Nodo(d, datos);
  talla++;  // Asi se mantiene el campo talla actualizado,
            // lo que permite que el coste de Talla() sea O(1),
            // y el coste de Apilar(d) sigue siendo O(1).
}

template <class T>
void Pila<T>::Desapilar() {
  if (datos != NULL) {
    Nodo *aux = datos;
    datos = datos->sig;
    delete aux;
    talla--;
  }
}

template <class T>
int Pila<T>::Talla() const {
  return talla;
}

template <class T>
bool Pila<T>::EstaVacia() const {
  return talla==0;
}

template <class T>
void Pila<T>::Vaciar(){
  Nodo *aux;
  while(datos != NULL) {
    aux = datos;
    datos = datos->sig;
    delete aux;
  }
  talla = 0;
}

// Otra solucion, algo mas estructurada, algo menos eficiente
// template <class T>
// void Pila<T>::Vaciar(){
//   while(! EstaVacia())
//     Desapilar();
// }


template <class T>
T & Pila<T>::Tope() throw(int) {
  if(datos != NULL)
    return datos->dato;
  else
    throw -1;
}