/**
  * classe CLL
  * Lista di Elementi Comparabili
  * prova di programmazione del 14-12-2007
  * la lista e' realizzata tramite lista concatenata
  * @author A. Luchetta
  * @version: 12-12-2007
  */
  
import java.util.NoSuchElementException;

public class CLL implements CList
{
   // variabili di esemplare
   private ListNode head;
   private int size;

   public CLL()
   {
      head = new ListNode();
      size = 0;  
   }

   /**
      restituisce il numero di elementi contenuti in questa lista
      @return numero di elementi contenuti nella lista
   */
   public int size()
   {
       return size;  
   }
   
   /**
      restituisce un iteratore su questa lista.
      @ iteratore su questa lista
   */
   public CListIterator getIterator()
   {
      return new LinkedListIterator(head, null);
   }
   
   class LinkedListIterator implements CListIterator
   {
      ListNode current;
      ListNode previous;
      
      public LinkedListIterator(ListNode c, ListNode p)
      {
         current = c;
         previous = p;
      }

      /**
         restituisce true se questo iteratore ha altri elementi
         @return true se l'iteratore ha altri elementi
      */
      public boolean hasNext()
      {
         return current.next != null;
      }
   
      /**
         restituisce il prossimo elemento nella lista
         @return il prossimo elemento di questa lista
         @throws NoSuchElementException
      */
      public Object next()
      {
         if (!hasNext())
            throw new NoSuchElementException();
            
         previous = current;
         current = current.next;
         
         return current.element;
      }
   
      /**
         inserisce l'elemento specificato nella lista. L'elemento e' inserito immediatamente prima
         del prossimo elemento che sarebbe restituito da next.
         @param x l'elemento da inserire 
      */
      public void add(Comparable x)
      {
         current.next = new ListNode(x, current.next);
         current = current.next;
         previous = null;
         size++;
      }

      /**
         rimuove dalla lista l'ultimo elemento restituito da next.
         @throws IllegalStateException se non e' stato precedentemente invocato il metodo next.
      */
      public void remove()
      {
         if (previous == null)
            throw new IllegalStateException();
            
         previous.next = current.next;
         current = previous;
         previous = null;
         size--;  
      }    
   }
   
   // classe interna ListNode
   class ListNode
   {
      Comparable element;
      ListNode next;
      
      public ListNode(Comparable e, ListNode n)
      {
         element = e;
         next = n;
      }
      
      public ListNode()
      {
         this(null, null);
      }
   }
}