// IG17 2004-05
// EjemploColaPrioridad.cpp
// 17-12-2004, 18-12-2004

// Ejemplo de uso de la clase generica ColaPrioridad.

// Para compilar: g++ EjemploColaPrioridad.cpp -o EjemploColaPrioridad
// No es necesario generar ColaPrioridad.o ni enlazarlo. Se incluye ColaPrioridad.cpp.

// Esto no es un test para comprobar que todo funciona correctamente.
// solo ilustra como se puede hacer uso de la clase.

#include <iostream>
using namespace std;

#include "ColaPrioridad.cpp"

class  Avion { // Clase ficticia simplemente para probar que podemos
               // crear instancias de la clase ColaPrioridad que guarden objetos de
               // una clase nuestra. Para ello necesitamos incluir ColaPrioridad.cpp.
  float duracionVuelo;
  int cantidadPasajeros;
  int prioridad;
 public:
  Avion(float, int);

  bool operator< (const Avion &) const; 
    // Ejercicio: Quita el ultimo const de la linea anterior, compila,
    // y asegurate de que entiendes el error de compilacion que aparece.

  friend ostream & operator<<(ostream &, const Avion &) ;
};

Avion::Avion(float d, int c) : duracionVuelo(d), cantidadPasajeros(c) {
  // Asignamos 3 niveles de prioridad ficticios, dando un nivel de
  // prioridad menor a los aviones que queremos que salgan antes de la cola
  if (duracionVuelo < 3)
    prioridad = 1;
  else if (cantidadPasajeros > 500)
    prioridad = 2;
  else
    prioridad = 3;
}

bool Avion::operator< (const Avion &a) const {
  // En la cola de prioridad se utilizara este operador para averiguar
  // cual es el avion de menor prioridad.
  return prioridad < a.prioridad;
}

ostream & operator<< (ostream &os, const Avion &a) {
  os << "(Prioridad:" << a.prioridad << ",Pasajeros:" << a.cantidadPasajeros << ",Duracion:" << a.duracionVuelo << ")";
  return os;
}

int main () {
  ColaPrioridad<Avion> c;

  c.Insertar(Avion(5.5, 500));
  c.Insertar(Avion(7.7, 700));
  c.Insertar(Avion(3.3, 300));
  c.Insertar(Avion(2.2, 200));
  c.Insertar(Avion(9.9, 900));
  
  cout << "Tenemos en la cola los aviones: ";
  c.Ver();
  cout << endl;

  while(!c.EstaVacia()) {
    cout << "Le toca despegar a: " << c.Minimo() << endl;;
    c.EliminarMinimo();
  }

 // Fijate en que un programa que, como este, realiza n llamadas a Insertar
 // y n llamadas a EliminarMinimo tiene un tiempo de ejecucion O(n*n) con
 // la implementacion de la cola de prioridad que utiliza una lista
 // desordenada con acceso directo al minimo. Tambien tendria un tiempo
 // de ejecucion O(n*n) con una cola de prioridad que utilizase una
 // lista ordenada. Pero su tiempo se reduciria a O(n log n) con una
 // cola de prioridad que utilizase un monticulo.

 // Con un buen disenyo orientado a objetos, podemos mas adelante cambiar
 // una implementacion de la cola de prioridad por otra totalmente diferente
 // sin que haya que cambiar nada en los programas que, como este, la
 // estan usando.
}