SimpleList

import java.lang.reflect.Array;

public class SimpleList<T> {

    private class Node {
    private T value;
    private Node next;
    public Node(T value) { this(value, null); }//add constructor
    public Node(T value, Node next) {
        this.next = next;
        this.value = value;
    }
    // Accessor methods
    public T getElement() { return value; }
    public Node getNext() { return next; }
    // Modifier methods
    public void setElement(T v) { value = v; }
    public void setNext(Node n) { next = n; }
    }

    // MyList class
    private Node head;
    // Implement required methods here
    public SimpleList(SimpleList rhs){
        head = null;
    }
    public SimpleList (T[] tArray, int n){//-----------------------------------MyList char[] int
        for(int i=0; i<n; i++){
            this.pushBack(tArray[i]);
        }
    }
    public boolean remove (int index){//-------------------------------------boolean remove index
        if(this.size()==0){
            System.out.println("No entries to remove.");
            return false;
        }
        else{
            if(index<0 || index>this.size()){
                System.out.println("Not a valid index number.");
                return false;
            }
            else{
                if(index == 0){     //remove object 0
                    Node temp = head;
                    head = head.next;
                    temp.next = null;
                }
                else if(index == this.size()){  //remove last object
                    Node temp = getNode(index-1);
                    temp.next = null;
                }
                else{       //remove object inside list
                    Node temp1 = getNode(index-1);
                    Node temp2 = getNode(index);
                    Node temp3 = getNode(index+1);
                    temp1.next = temp3;
                    temp2.next = null;
                }
                return true;
            }
        }
    }
    public boolean remove (T value){//-------------------------------------boolean remove char
        int index = this.find(value);
        boolean x = remove(index);
        return x;
    }
    public Node previous(Node curr){
        int i=0;
        while(getNode(i)!=curr)
            i++;
        return getNode(i-1);
        }
    public Node next(Node curr){return curr.next;}
    public T getAt(int index){//--------------------------------------------char get index
        Node temp1 = head;
        for(int i=0; i<index; i++){
            if(temp1.next != null)
                temp1 = temp1.next;
        }
        return temp1.value;
    }
    private Node getNode(int index){//-----------------------------------------Node getNode index
        Node temp1 = head;
        for(int i=0; i<index; i++){
            if(temp1.next != null)
                temp1 = temp1.next;
        }
        return temp1;
    }
    public void set(int index, T value){//-----------------------------------void set index value
        if(index<0 || index>this.size()){
            System.out.println("Invalid index number.");
        }
        else
            getNode(index).value = value;
    }
    public void swap(int i, int j){//--------------------------------------------void swap int int
        if(this.size()==0)
            System.out.println("No entries to swap.");
        else{
            if((i>=0)&&(i<=this.size())&&(j>=0)&&(j<=this.size())){
                Node temp1 = getNode(i);
                Node temp2 = getNode(j);
                this.remove(j);
                this.insertAtPos(j, temp1.value);
                this.remove(i);
                this.insertAtPos(i, temp2.value);
            }
            else
                System.out.println("Not a valid index number.");
        }
    }
    public void pushBack(T t){//----------------------------------------void pushBack char
        this.insertAfter(this.size(), t);
    }
    public void insertAtPos(int i, T value){//--------------------------------void insertAtPos int char
        Node temp = new Node(value,null);
        if(this.size()==0){
            head = temp;
        }
        else{
            if((i>this.size())||(i<0)){ //index out of list
                System.out.println("Not a valid index number.");
            }
            else if(i==this.size()){//insert at end
                getNode(i).next = temp;
            }
            else if(i==0){      //insert at beginning
                temp.next = getNode(i);
                head = temp;
            }
            else{               //insert inside list
                temp.next = getNode(i);
                getNode(i-1).next = temp;
            }
        }
    }
    public void insertAfter(int i, T value){//-------------------------------void insertAfter int char
        Node temp = new Node(value,null);
        if(this.size()==0){
            head = temp;
        }
        else{
            if((i>this.size())||(i<0)){ //index out of list
                System.out.println("Not a valid index number.");
            }
            else if(i==this.size()){//insert at end
                getNode(i).next = temp;
            }
            else{               //insert inside list
                temp.next = getNode(i+1);
                getNode(i).next = temp;
            }
        }
    }
    public SimpleList sublist(int fromIndex, int toIndex){//------------------MyList sublist int int
        SimpleList sublist = new SimpleList(null);
        if((fromIndex>=0)&&(fromIndex<=this.size())&&(toIndex>=0)&&(toIndex<=this.size())){
            for(int i=fromIndex; i<=toIndex; i++){
                sublist.pushBack(getAt(i));
            }
        }
        else
            System.out.println("Invalid index numbers provided.");
        return sublist;
    }
    public int find(T value){ //--------------------------------------------int find char
        Node temp = head;
        int i =0;
        while((temp.value!=value)&&(i<this.size())){
            i++;
            if(temp.next!=null)
                temp = temp.next;
            }
        if(temp.value == value)
            return i;
        else{
            System.out.println("Value '"+value+"' not found.");
            return -1;
        }
    }
    public int find(SimpleList queryStr){return 0;/*remove later*/}
    @SuppressWarnings("unchecked")
    public T[] toArray(Class<T> t){//------------------------------------------------char[] toArray
        T[] tArray;
        //@SupressWarnings("unchecked")
        tArray = (T[])Array.newInstance(t,this.size());
        if(head != null){
            for(int i=0; i<this.size(); i++){
                tArray[i] = getNode(i).value;
            }
        }
        else
            System.out.println("No valid entries.");
        return tArray;
    }
    public int size(){//------------------------------------------------------------------int size
        int i=0;
        if(head!=null){
            //i++;
            Node temp = head;
            while(temp!=null){
                temp = temp.next;
                i++;
            }
        }
        return i;
    }
    public void print(){//-------------------------------------------------------------void print
        for(int i=0; i<this.size() ; i++){
            System.out.println(getNode(i).value);
        }
    }
    public String toString(){//------------------------------------------------------string toString
        StringBuilder string = new StringBuilder(this.size());
        for(T c: this.toArray(null))
            string.append(c);
        return string.toString();
    }
}