SortedCircularSortedLL

package Lists;


import java.util.Iterator;
import java.util.NoSuchElementException;

import models.Contact;




public class SortedCircularDoublyLL<E> implements List<E> {

	private class Node {
		private E value;
		private Node next;
		private Node prev;

		public E getValue() {
			return value;
		}
		public void setValue(E value) {
			this.value = value;
		}
		public Node getNext() {
			return next;
		}
		public void setNext(Node next) {
			this.next = next;
		}
		public Node getPrev() {
			return prev;
		}
		public void setPrev(Node prev) {
			this.prev = prev;
		}


	}

	private class ListIterator implements Iterator<E>{

		private Node nextNode;

		public ListIterator(){
			this.nextNode = header.getNext();
		}

		public ListIterator(int i){
			this.nextNode = header.getNext();
			for(int index=0;index<i;index++){
				this.nextNode=this.nextNode.getNext();
			}
		}


		public boolean hasNext() {
			return true;
		}


		public E next() {
			if (hasNext()){
				E result = this.nextNode.getValue();
				this.nextNode = this.nextNode.getNext();
				return result;
			}
			else {
				throw new NoSuchElementException();
			}
		}


		public void remove() {
			throw new UnsupportedOperationException();

		}

	}


	private class ReverseListIterator implements ReverseIterator<E>{

		private Node prevNode;

		public ReverseListIterator(){
			Node temp = null;
			if (!isEmpty()){
				for (temp = header.getNext(); temp.getNext() != header; temp = temp.getNext());
				prevNode = temp;
			}
			else  {
				prevNode = header;
			}
		}

		public boolean hasPrev() {
			return true;
		}


		public E prev() {
			if (hasPrev()){
				E result = prevNode.getValue();
				prevNode = prevNode.getPrev();
				return result;
			}
			else {
				throw new NoSuchElementException();

			}
		}


		public void remove() {
			throw new UnsupportedOperationException();

		}

	}
	private Node header, last;
	private int currentSize;

	public SortedCircularDoublyLL(){
		this.header = new Node();
		this.last = header;
		this.header.setNext(last);
		this.header.setPrev(last);
		this.currentSize = 0;
	}


	public Iterator<E> iterator() {
		return new ListIterator();
	}

	public Iterator<E> iterator(int i) {
		return new ListIterator(i);
	}

	public ReverseIterator<E> reverseIterator() {
		return new ReverseListIterator();
	}


	public void add(E obj) {

		if (obj == null){
			throw new IllegalArgumentException("Parameter cannot be null.");
		}

		Node temp = this.header.getNext();
		Node prevtemp= this.header;

		if(this.currentSize==0){
			Node newNode=new Node();
			newNode.setValue(obj);
			this.header.setNext(newNode);
			this.header.setPrev(newNode);
			newNode.setNext(this.header);
			newNode.setPrev(this.header);
		}
		else if(temp.getValue() instanceof Contact && this.currentSize>0){
			while(temp!=this.header && ((Contact) obj).getLastName().compareTo(((Contact ) temp.getValue()).getLastName())>0){
				temp=temp.getNext();
				prevtemp=prevtemp.getNext();
			}
			if(temp==this.header){
				Node newNode = new Node();
				newNode.setValue(obj);
				newNode.setNext(this.header);
				newNode.setPrev(prevtemp);
				prevtemp.setNext(newNode);
				this.header.setPrev(newNode);
			}
			else{
				Node newNode = new Node();
				newNode.setValue(obj);
				newNode.setNext(temp);
				newNode.setPrev(prevtemp);
				prevtemp.setNext(newNode);
				temp.setPrev(newNode);
			}


		}
		else if(!(temp.getValue() instanceof Contact) & this.currentSize>0) {
			while(temp!=this.header && ((Comparable) obj).compareTo(temp.getValue()) > 0){
				temp=temp.getNext();
				prevtemp=prevtemp.getNext();
			}
			if(temp==this.header){
				Node newNode = new Node();
				newNode.setValue(obj);
				newNode.setNext(this.header);
				newNode.setPrev(prevtemp);
				prevtemp.setNext(newNode);
				this.header.setPrev(newNode);
			}
			else{
				Node newNode = new Node();
				newNode.setValue(obj);
				newNode.setNext(temp);
				newNode.setPrev(prevtemp);
				prevtemp.setNext(newNode);
				temp.setPrev(newNode);
			}
		}
		this.currentSize++;
	}



	public boolean remove(E obj) {
		if (obj == null){
			throw new IllegalArgumentException("Parameter cannot be null.");
		}
		Node temp = null;
		for (temp = header.getNext(); temp != this.header; temp = temp.getNext()){
			if (temp.getValue().equals(obj)){
				// found first copy
				if (temp.getNext() != null){
					temp.getNext().setPrev(temp.getPrev());
				}
				temp.getPrev().setNext(temp.getNext());
				temp.setValue(null);
				temp.setNext(null);
				temp.setPrev(null);
				this.currentSize--;
				return true;
			}
		}
		return false;
	}


	public boolean remove(int index) {
		if ((index < 0) || (index >= this.size())){
			throw new IndexOutOfBoundsException();
		}

		Node temp = null;
		int counter = 0;
		for (temp = header.getNext(); counter < index; temp = temp.getNext(), counter++);
		if (temp.getNext() != null){
			// i am not at the end of list
			temp.getNext().setPrev(temp.getPrev()); // null if temp is the last one
		}
		temp.getPrev().setNext(temp.getNext());
		temp.setValue(null);
		temp.setNext(null);
		temp.setPrev(null);
		this.currentSize--;
		return true;
	}


	public int removeAll(E obj) {
		int counter = 0;
		while(this.remove(obj)){
			counter++;
		}
		return counter;
	}


	public E get(int index) {
		if ((index < 0) || (index >= this.size())){
			throw new IndexOutOfBoundsException();
		}
		else {
			int counter = 0;
			Node temp = null;
			for (temp = header.getNext(); counter < index; temp = temp.getNext(), counter++);
			return temp.getValue();
		}
	}


	public E set(int index, E obj) {
		if (obj == null){
			throw new IllegalArgumentException("Parameter cannot be null.");
		}

		if ((index < 0) || (index >= this.size())){
			throw new IndexOutOfBoundsException();
		}
		else {
			int counter = 0;
			Node temp = null;
			for (temp = header.getNext(); counter < index; temp = temp.getNext(), counter++);
			E result = temp.getValue();
			temp.setValue(obj);
			return result;
		}
	}


	public E first() {
		if (this.isEmpty()){
			return null;
		}
		else {
			return header.getNext().getValue();
		}
	}


	public E last() {
		if (this.isEmpty()){
			return null;
		}
		else {
			Node temp = null;
			for (temp = header.getNext(); temp.getNext() != this.header; temp = temp.getNext());
			return temp.getValue();
		}


	}

	public Node lastNode() {
		if (this.isEmpty()){
			return null;
		}
		else {
			Node temp = null;
			for (temp = header.getNext(); temp.getNext() != null; temp = temp.getNext());
			return temp;
		}


	}


	public int firstIndex(E obj) {
		if (obj == null){
			throw new IllegalArgumentException("Parameter cannot be null.");
		}
		else {
			int counter = 0;
			Node temp = null;
			for (temp = header.getNext(); temp != this.header; temp = temp.getNext(), counter++){
				if(temp!=null||temp!=header){
					if (temp.getValue().equals(obj)){
						return counter;
					}
				}
			}
			return -1;
		}
	}


	public int lastIndex(E obj) {
		if (obj == null){
			throw new IllegalArgumentException("Parameter cannot be null.");
		}
		else {
			int counter =0, lastSeen = -1;
			Node temp = null;
			for (temp = header.getNext(); temp != this.header; temp = temp.getNext(), counter++){
				if (temp.getValue().equals(obj)){
					lastSeen = counter;
				}
			}
			return lastSeen;
		}
	}


	public int size() {
		return this.currentSize;
	}


	public boolean isEmpty() {
		return this.size() == 0;
	}


	public boolean contains(E obj) {
		return this.firstIndex(obj) >= 0;
	}


	public void clear() {
		while (!this.isEmpty()){
			this.remove(0);
		}

	}

}