import java.util.NoSuchElementException;
/**
 * Implementacion de la interfaz Listable utilizando nodos ligados y un nodo 
 * centinela al inicio de la lista.
 * @author Amparo López Gaona 
 * @version 1a. ed.
 */

public class Lista1 implements Listable{
  private Nodo inicio;

  /**  
   * Construye la lista vacia
   */
  public Lista1() {
    inicio = null;
  }

  /** 
   * Constructor de copia
   * @param lista -- lista que se copiara
   */
  public Lista1 (Lista1 lista) {
    inicio = new Nodo(lista.inicio);
    Nodo lis = lista.inicio;
    Nodo pos = inicio;

    while (lis != null) {
      pos = new Nodo(lis);
      lis = lis.sgte;
    }
  }

  /**
   * Metodo que prueba que la lista esta vacia. 
   * @return true si esta vacia y false en otro caso.
   */
  public boolean estaVacia() {
    return inicio == null;
  }

  /** 
   * Metodo para dejar una lista vacia. 
   */
  public void vaciar() {
    inicio = null;
  }

  /** 
   * Metodo que devuelve el primer elemento de la lista
   * @return Object -- primer elemento almacenado en la lista
   * @throws NoSuchElementException -- excepcion que se dispara si la lista esta vacia
   **/
  public Object primerElemento() {
      if (!estaVacia())
	  return inicio.elemento;
      throw new NoSuchElementException("La lista no tiene elementos");
  }

  /**
   * Metodo que devuelve un valor booleando indicando si el elemento esta en la lista
   * @param dato -- el objeto a buscar.
   * @return boolean -- devuelve true si el elemento esta en la lista y false
   *                 en caso contrario
   */
  public boolean contiene(Object dato) {
      return buscar(dato) != null;
  }

  /*
   * Metodo interno que devuelve el nodo que contiene el dato buscado.
   * @param dato el objeto a buscar.
   * @return nodo - el nodo que contiene el dato buscado o null si el dato 
   *         no se encuentra en la lista.
   */
    private Nodo buscar (Object dato) { 
    Nodo pos = inicio;

    while(pos != null && ! pos.elemento.equals(dato)) 
      pos = pos.sgte;
    return pos;
    }

  /**
   * Metodo que sustituye el valor actual de un nodo por otro nuevo.
   * @param orig -- valor original
   * @param nuevo -- nuevo valor
   * @throws NoSuchElementException - si el elemento no se encuentra en la lista
   */
    public void sustituir(Object orig, Object nuevo) {
    Nodo n = buscar(orig);
    if ( n!= null)
	n.elemento = nuevo;
    else
     throw new java.util.NoSuchElementException("El elemento "+orig + " no esta en la lista");
    }

  /**
   * Metodo para insertar el primer elemento de la lista.
   * @param dato -- el dato a agregar.
   */
  public void agregar(Object dato) {
    inicio = new Nodo(dato,inicio);
  }


  /**
   * Metodo para eliminar la primera ocurrencia de un elemento.
   * @param dato -- elemento que se desea eliminar de la lista.
   */
  public void eliminar(Object dato) { 
    Nodo pos = inicio, anterior = null;

    while(pos != null && !pos.elemento.equals(dato)) {
      anterior = pos;
      pos = pos.sgte;
    }
    if (pos != null) {
    if(pos == inicio)          // Es el inicio de la lista
	inicio = inicio.sgte;
    else 
      anterior.sgte = pos.sgte; 
    }
  }

  /**
   * Metodo que devuelve un iterador sobre la lista
   * @return java.util.Iterador -- iterador sobre la lista
   */
  public java.util.Iterator iterador() { 
    return new MiIterador(); 
  }
	
  /*
   * Clase interna que implementa el iterador
   */
  private class MiIterador implements java.util.Iterator {
    private Nodo posicion = inicio;

    public boolean hasNext() { return posicion != null;}

    public Object next() throws java.util.NoSuchElementException {
      if (hasNext()) {
	Object o = posicion.elemento;
	posicion = posicion.sgte;
	return o;
      }
      throw new java.util.NoSuchElementException();
    }

    public void remove() {
      throw new IllegalStateException();
    }
  }
}