public interface IListIterator<E>  {

    void add (E e);
    boolean hasNext();
    boolean hasPrevious();
    E next();
    int nextIndex();
    E previous();
    int previousIndex();
    void remove();
    void removeAll(E value);
    void serialise();
    void showAll();

}




public abstract class AbstractList<E> implements IList<E> {
    @Override
    public String toString() {
        StringBuffer buffer =  new StringBuffer();
        buffer.append("[");
        if(!isEmpty()){
            for(E item:this)
                buffer.append(item).append(",");
            buffer.setLength(buffer.length() - 2);
        }
        buffer.append("]");
        return buffer.toString();
    }

    public int hashCode(){
        int hashCode = 0;
        for(E item: this)
            hashCode ^= item.hashCode();
        return hashCode;
    }

    public boolean equals(Object object){
        if(object == null)
            return false;
        if(getClass() != object.getClass())
            return false;
        return equals((IList<E>)object);
    }

    public boolean equals(IList<E> other){
        if(other ==  null || size() != other.size())
            return false;
        else{
            Iterator <E> i = iterator();
            Iterator<E> j = other.iterator();
            boolean has1= i.hasNext();
            boolean has2 = j.hasNext();

            for(;has1 && has2 && i.next().equals(j.next());){
                has1 = i.hasNext();
                has2 = j.hasNext();
            }
            return !has1 && !has2;
        }
    }

}


public class OneWayLinkedList<E> extends AbstractList<E> {
    private class Element{
        private E value;
        private Element next;

        public E getValue() {
            return value;
        }

        public void setValue(E value) {
            this.value = value;
        }

        public Element getNext() {
            return next;
        }

        public void setNext(Element next) {
            this.next = next;
        }

        Element(E data){
            this.value=data;
        }
    }

    private class InnerIterator implements Iterator<E>{
        Element actElem;

        public InnerIterator() {
            actElem = head;
        }

        @Override
        public boolean hasNext() {
            return actElem != null;
        }

        @Override
        public E next() {
            E value = actElem.getValue();
            actElem = actElem.getNext();
            return value;
        }

        public void showAll(){

            Element actElem = head;
            while(actElem != null){
                System.out.println(actElem);
                actElem = actElem.getNext();
            }

        }
    }

    private class InnerListIterator implements IListIterator<E> {

        int pos = -1;

        @Override
        public void add(E e) {
            OneWayLinkedList.this.add(pos+1, e);
        }

        @Override
        public boolean hasNext() {
            return pos<size();
        }

        @Override
        public boolean hasPrevious() {
            return pos >= 0;
        }

        @Override
        public E next() {
            if(hasNext()) {
                pos = pos + 1;
                return get(pos + 1);
            }
            return null;

        }

        @Override
        public int nextIndex() {
            if(hasNext())
                return pos+1;
            else
                return -1;
        }

        @Override
        public E previous() {
            return null;
        }

        @Override
        public int previousIndex() {
            if(hasPrevious())
                return pos-1;
            else
                return -1;
        }

        @Override
        public void remove() {

        }

        @Override
        public void removeAll(E value) {



        }

        @Override
        public void serialise() {

        }

        @Override
        public void showAll() {
            Element actElem =  head;
            while(actElem != null){
                System.out.println(actElem.getValue());
                actElem = actElem.getNext();
            }
        }
    }

    private Element getElement(int index){
        if (index<0) throw new IndexOutOfBoundsException();
            Element actElem = head;
        while(index > 0 && actElem != null){
            index --;
            actElem = actElem.getNext();
        }
        if(actElem == null) throw new IndexOutOfBoundsException();

        return actElem;

    }


    Element head =  null;

    public OneWayLinkedList() {}

    @Override
    public boolean add(E e) {
        Element newElem = new Element(e);
        if(head == null){
            head = newElem;
            return true;
        }
        Element tail = head;
        while(tail.getNext() != null){
            tail = tail.getNext();
        }
        tail.setNext(newElem);

        return true;
    }

    @Override
    public void add(int index, E element) {
        if(index < 0) throw new IndexOutOfBoundsException();
        Element newElem = new Element(element);
        if(index == 0){
            newElem.setNext(head);
            head = newElem;
        }
        Element actElem = getElement(index -1);
        newElem.setNext(actElem.getNext());
        actElem.setNext(newElem);
    }

    @Override
    public void clear() {
        head = null;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element)>= 0;
    }

    @Override
    public E get(int index) {
        Element actElement = getElement(index);
        return actElement.getValue();
    }

    @Override
    public E set(int index, E element) {
        Element actElement = getElement(index);
        E elemData = actElement.getValue();
        actElement.setValue(element);
        return elemData;
    }

    @Override
    public int indexOf(E element) {
        int pos = 0;
        Element actElem =  head;
        while(actElem != null){
            if(actElem.getValue().equals(element))
                return pos;
            pos++;
            actElem = actElem.getNext();
        }
        return -1;
    }

    @Override
    public boolean isEmpty() {
        return head == null;
    }

    @Override
    public Iterator<E> iterator() {
        return new InnerIterator();
    }

    @Override
    public IListIterator<E> listIterator() {
        return new InnerListIterator(); }

    @Override
    public E remove(int index) {
        if(index < 0 || head == null) throw new IndexOutOfBoundsException();
        if (index == 0){
            E retValue = head.getValue();
            head = head.getNext();
            return retValue;
        }
        Element actElem = getElement(index - 1);
        if(actElem.getNext() == null)
            throw new IndexOutOfBoundsException();
        E retValue =  actElem.getNext().getValue();
        actElem.setNext(actElem.getNext().getNext());
            return retValue;
    }

    @Override
    public boolean remove(E element) {
        if(head == null)
            return false;
        if(head.getValue().equals(element)){
            head = head.getNext();
            return true;
        }
        Element actElem = head;
        while(actElem.getNext() != null && !actElem.getNext().getValue().equals(element))
            actElem= actElem.getNext();
        if (actElem.getNext() == null)
            return false;
        actElem.setNext(actElem.getNext().getNext());
            return true;
    }

    @Override
    public int size() {
        int pos = 0;
        Element actElem =  head;
        while(actElem != null){
            pos++;
            actElem = actElem.getNext();
        }
        return pos;
    }
}