// II17 2005-06
// PilaEnteros.cpp
// 18-11-2005

#include <iostream>
using namespace std;

#include "PilaEnteros.h"

PilaEnteros::Nodo::Nodo(int d, Nodo *s) : dato(d), sig(s) {
}

PilaEnteros::PilaEnteros() : datos(NULL), talla(0) {
}

PilaEnteros::PilaEnteros (const PilaEnteros & p) : datos(NULL), talla(0) {
  *this = p;
}

PilaEnteros & PilaEnteros::operator= (const PilaEnteros &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;
}

PilaEnteros::~PilaEnteros(){
  Vaciar();
}

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

void PilaEnteros::Apilar(int 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).
}

void PilaEnteros::Desapilar() {
  if (datos != NULL) {
    Nodo *aux = datos;
    datos = datos->sig;
    delete aux;
    talla--;
  }
}

int PilaEnteros::Talla() const {
  return talla;
}

bool PilaEnteros::EstaVacia() const {
  return talla==0;
}

void PilaEnteros::Vaciar(){
  Nodo *aux;
  while(datos != NULL) {
    aux = datos;
    datos = datos->sig;
    delete aux;
  }
  talla = 0;
}

// Otra solucion, algo mas estructurada, algo menos eficiente
// void PilaEnteros::Vaciar(){
//   while(! EstaVacia())
//     Desapilar();
// }


int & PilaEnteros::Tope() throw(int) {
  if(datos != NULL)
    return datos->dato;
  else
    throw -1;
}