public interface PSDLL {

   public int replace (int place, int item) throws InvalidPositionException;
   public void insertBefore (int place, int item) throws InvalidPositionException;
   public void insertAfter (int place, int item) throws InvalidPositionException;
   public void swap (int place1, int place2) throws InvalidPositionException;
   public int delete (int place) throws InvalidPositionException;
   public int before (int place) throws InvalidPositionException;
   public int after (int place) throws InvalidPositionException;
   public void insertFirst (int item);
   public void insertLast (int item);
   public PSDLNode deleteFirst ();
   public PSDLNode deleteLast ();
   public int size();
   public int last ();
   public int first ();
   public boolean empty ();
   public void traverse ();

}

class InvalidPositionException extends Exception {
   public InvalidPositionException (String message) {
      System.out.println(message);
   }
}

class PSDLNode {

   private int data;
   private PSDLNode next, prev;
   int pos;

   public PSDLNode () {
   }

   public PSDLNode (int d) {
     data = d;
   }
  
   public PSDLNode (int newData, PSDLNode newNext, 
                      PSDLNode newPrev, int newPos) {
     data = newData;
     next = newNext;
     prev = newPrev;
     pos = newPos;
   }

   public void setData (int newData) {
     data = newData;
   }

   public void setNext (PSDLNode newNext) {
     next = newNext;
   } 

   public void setPrev (PSDLNode newPrev) {
     prev = newPrev;
   }

   public void setPosition (int newPos) {
     pos = newPos;
   }

   public int getData () {
     return data;
   }

   public PSDLNode getNext () {
      return next;
   }

   public PSDLNode getPrev () {
      return prev;
   }

   public int getPosition () {
      return pos;
   } 

   public void displayPSDLNode () {
      System.out.print ("data " + data + "; position " + pos);
      System.out.println ();
      
   }
 
}

class PSDLLADT implements PSDLL {

   private PSDLNode header;
   private PSDLNode trailer;
   private int size;
   int position;

   /* first and last are dummy nodes that do not store
      any data */

   public PSDLLADT () {
     header = new PSDLNode();
     trailer = new PSDLNode();
     header.setNext(trailer);
     header.setPrev(null);
     header.setData(0);
     header.setPosition(0);
     trailer.setPrev(header);
     trailer.setNext(null); 
     trailer.setData(0);
     trailer.setPosition(0);
     size = 0;
   }

   public boolean empty () {
     return (size == 0);
   }

   public int size () {
      return size;
   }     

   public int before (int place) throws InvalidPositionException {
      return (searchNode(place)).getPrev().getPosition();
   }

   public int after (int place) throws InvalidPositionException {
      return (searchNode(place)).getNext().getPosition();
   }

   public void insertFirst (int newData) {
      position++;     
      PSDLNode oldFirst = header.getNext(); 
      PSDLNode newFirst = new PSDLNode 
                 (newData, oldFirst, header, position);
      oldFirst.setPrev(newFirst);
      header.setNext(newFirst);
      size++;
   }

   public void insertLast (int newData) {
      position++;
      PSDLNode oldLast = trailer.getPrev(); 
      PSDLNode newLast = new PSDLNode 
                (newData, trailer, oldLast, position);
      oldLast.setNext(newLast);
      trailer.setPrev(newLast);
      size++;
   }

   public PSDLNode deleteFirst () {
      PSDLNode oldFirst = header.getNext();
      PSDLNode newFirst = oldFirst.getNext();
      newFirst.setPrev(header);
      header.setNext(newFirst);
      size--;
      return oldFirst;
   }

   public PSDLNode deleteLast () {
      PSDLNode oldLast = trailer.getPrev();
      PSDLNode newLast = oldLast.getPrev();
      trailer.setPrev(newLast);
      newLast.setNext(trailer);
      size--;
      return oldLast;
   }

   private PSDLNode searchNode (int position) 
                  throws InvalidPositionException {
      PSDLNode current = header.getNext();
      while (current != trailer) {
         if (current.getPosition () == position) 
            return current;
         else
            current = current.getNext();
      }
      throw new InvalidPositionException 
        ("An invalid position was passed to the searchNode method.");

   }      
      
   public int delete (int place) throws 
                          InvalidPositionException {
      PSDLNode temp = searchNode (place);
      int oldItem = temp.getData();
      PSDLNode oldNext = temp.getNext();
      PSDLNode oldPrev = temp.getPrev();
      oldNext.setPrev(oldPrev);
      oldPrev.setNext(oldNext);
      size--;
      return oldItem;
   }
   
   public int replace (int place, int newData) 
                           throws InvalidPositionException {
      PSDLNode temp = searchNode (place);
      int oldItem = temp.getData();
      temp.setData(newData);
      return oldItem;
   }

   public void swap (int place1, int place2) 
                           throws InvalidPositionException {
      PSDLNode node1 = searchNode(place1);
      PSDLNode node2 = searchNode(place2);
      PSDLNode temp = new PSDLNode();
      temp.setData(node1.getData());
      node1.setData(node2.getData());
      node2.setData(temp.getData());
   }

   public void insertBefore (int place, int newData) 
                           throws InvalidPositionException {
      position++;
      PSDLNode temp = searchNode (place);
      PSDLNode newNode = new PSDLNode 
                   (newData, temp, temp.getPrev(), position);
      temp.getPrev().setNext(newNode);
      temp.setPrev(newNode);
      size++;
   }

   public void insertAfter (int place, int newData) 
                           throws InvalidPositionException {
      position++;
      PSDLNode temp = searchNode (place);
      PSDLNode newNode = new PSDLNode 
                     (newData, temp.getNext(), temp, position);
      temp.getNext().setPrev(newNode);
      temp.setNext(newNode);
      size++;
   }

   public int last () {
      return (trailer.getPrev().getPosition());
   }

   public int first () {
      return (header.getNext().getPosition());
   }
      
   public void traverse () {
      System.out.println ("Current list: ");
      PSDLNode current = header.getNext();
      while (current != trailer) {
         current.displayPSDLNode ();
         current = current.getNext();
      }
      System.out.println ();
   }
}         


class PSDLLex1 {

   public static void main (String[] args)  {

     PSDLLADT list1 = new PSDLLADT ();

     for (int i = 1; i <= 3; i++) {
        list1.insertFirst(i);
        list1.traverse();    
     }

     System.out.println ("Number of nodes on the list: " + 
                                       list1.size());
     try {
     list1.replace(2,10); 
     list1.traverse();
     list1.insertAfter(2,15);
     list1.traverse();
     list1.insertBefore(2,17);  
     list1.traverse(); 
     list1.swap(3, 5);
     list1.traverse();
     list1.delete(2);
     list1.traverse(); }
     catch (InvalidPositionException e) { };
     System.out.println ("The last datum in the list is " + list1.last());
     System.out.println ("The first datum in the list is " + list1.first());
     for (int i = 1; i <= 3; i++) {
        list1.deleteFirst();
        list1.traverse();
     } 
   }
}
/*
     

class PSDLLex2 {

   public static void main (String[] args)  {

     PSDLLADT list1 = new PSDLLADT ();
     try {
     list1.insertFirst(8); 
     list1.traverse();
     list1.insertAfter(1, 5);
     list1.traverse();
     list1.insertBefore(2,3);
     list1.traverse();
     list1.insertFirst(9);  
     list1.traverse(); 
     System.out.println ("Position of the item before the one in position 3: "
             + list1.before(3));
     System.out.println ("Position of the last item in the sequence: " + list1.last());
     System.out.println();
     list1.delete(4);
     list1.traverse();
     list1.swap(1, 2);
     list1.traverse(); 
     list1.replace(3, 7); 
     list1.traverse();
     list1.insertAfter(list1.first(), 2); 
     list1.traverse(); }
     catch (InvalidPositionException e) { };
   }
}

*/