Posto il codice

codice:
public class NodePositionList<E> 
{
	
	protected int size;
	protected DNode<E> header, trailer;
	
	public NodePositionList()
	{
		header = new DNode<E>(null, null, null);
		trailer = new DNode<E>(header, null, null);
		header.setNext(trailer);
		size = 0;
	}
	
	public int size()
	{
		return size;
	}
	
	public boolean isEmpty()
	{
		return (size == 0);
	}
	
	public Position<E> first()
	{
		if(isEmpty())
			throw new EmptyListException("La lista è vuota");
		return header.getNext();
	}
	
	public Position<E> last()
	{
		if(isEmpty())
			throw new EmptyListException("La lista è vuota");
		return trailer.getPrev();
	}
	
	protected DNode<E> checkPosition(Position<E> p)
	{
		if(p == null) throw new InvalidPositionException("Nulla passato come posizione");
		if(p == header) throw new InvalidPositionException("header non è una posizione valida nella lista");
		if(p == trailer) throw new InvalidPositionException("trailer non è una posizione valida nella lista");
		
		try
		{
			DNode<E> temp = (DNode<E>) p;
			if((temp.getPrev() == null) || (temp.getNext() == null))
				throw new InvalidPositionException("La posizione non fa parte della lista");
			return temp;
		}
		catch(ClassCastException e)
		{
			throw new InvalidPositionException("Il tipo della posizione non è valido in questa lista");
		}
	}
	
	public Position<E> prev(Position<E> p)
	{
		DNode<E> v = checkPosition(p);
		DNode<E> prev = v.getPrev();
		
		if(prev == header)
			throw new BoundaryViolationException("Non posso retrocedere oltre l'inizio della lista");
		return prev;
	}
	
	public Position<E> next(Position<E> p)
	{
		DNode<E> v = checkPosition(p);
		DNode<E> next = v.getNext();
		
		if(next == trailer)
			throw new BoundaryViolationException("Non posso avanzare oltre la fine della lista");
		
		return next;
	}
	
	public void addAfter(Position<E> p, E e)
	{
		DNode<E> v = checkPosition(p);
		size++;
		DNode<E> newNodo = new DNode<E>(v, v.getNext(), e);
		v.getNext().setPrev(newNodo);
		v.setNext(newNodo);
	}
	
	public void addBefore(Position<E> p, E e)
	{
		DNode<E> v = checkPosition(p);
		size++;
		DNode<E> newNodo = new DNode<E>(v.getPrev(), v, e);
		v.getPrev().setNext(newNodo);
		v.setPrev(newNodo);
	}
	
	public void addFirst(E e)
	{
		size++;
		DNode<E> newNodo = new DNode<E>(header, header.getNext(), e); 
		header.getNext().setPrev(newNodo);
		header.setNext(newNodo);
	}
	
	public void addLast(E e)
	{
		size++;
		DNode<E> newNodo = new DNode<E>(trailer.getPrev(), trailer, e);
		trailer.getPrev().setNext(newNodo);
		trailer.setPrev(newNodo);
	}
	
	public E remove(Position<E> p)
	{
		DNode<E> v = checkPosition(p);
		size--;
		DNode<E> vPrev = v.getPrev();
		DNode<E> vNext = v.getNext();
		vPrev.setNext(vNext);
		vNext.setPrev(vPrev);
		E element = v.element();
		v.setNext(null);
		v.setPrev(null);
		return element;
	}


}