package set;

import position.NodePositionList;
import position.PositionList;
import utility.DefaultComparator;
import utility.merge.MergeTemplate;

import java.util.Comparator;

/**
 * Created with xgiovio.macbookair.
 * User: xgiovio
 * Date: 14/05/14
 * Time: 14:23
 */

public class OrderedListSet <E> implements Set<E> {
    private Comparator<E> c;
    private PositionList<E> L;



    public OrderedListSet() {
        L = new NodePositionList<E>();
        c = new DefaultComparator<E>();
    }

    public OrderedListSet(Comparator<E> in_c) {
        L = new NodePositionList<E>();
        c = in_c;
    }

    public OrderedListSet(PositionList<E> in_l){
        L = in_l;
        c = new DefaultComparator<E>();
    }

    public OrderedListSet(PositionList<E> in_l,Comparator<E> in_c ){
        L = in_l;
        c = in_c;
    }




    @Override
    public int size() {
        return L.size();
    }

    @Override
    public boolean isEmpty() {
        return L.isEmpty();
    }




    @Override
    public Set<E> union(Set<E> B) {
        MergeUnion<E> ret = new MergeUnion<E>(L, ((OrderedListSet<E>)B).L , c );
        L = ret.getResult();
        return this;

    }

    @Override
    public Set<E> intersect(Set<E> B) {
        MergeIntersect<E> ret = new MergeIntersect<E>(L, ((OrderedListSet<E>)B).L , c );
        L = ret.getResult();
        return this;
    }

    @Override
    public Set<E> subtract(Set<E> B) {
        MergeSubtract<E> ret = new MergeSubtract<E>(L, ((OrderedListSet<E>)B).L , c );
        L = ret.getResult();
        return this;
    }

    @Override
    public String toString() {
        return L.toString();
    }

    //////////////////////// inner class override methods from merge template /////

    protected class MergeUnion<E> extends MergeTemplate<E>{

           public MergeUnion (PositionList<E> A , PositionList<E> B, Comparator<E> c){
                 super(A,B,c);
           }

           @Override
           protected void aIsLess(E a) {
                  s.addLast(a);
           }

           @Override
           protected void bIsLess(E b) {
                    s.addLast(b);
           }

           @Override
           protected void bothAreEqual(E a, E b) {
                    s.addLast(a);
           }
       }

    protected class MergeIntersect<E> extends MergeTemplate<E>{

        public MergeIntersect (PositionList<E> A , PositionList<E> B, Comparator<E> c){
            super(A,B,c);
        }

        @Override
        protected void aIsLess(E a) {

        }

        @Override
        protected void bIsLess(E b) {

        }

        @Override
        protected void bothAreEqual(E a, E b) {
            s.addLast(a);
        }
    }

    protected class MergeSubtract<E> extends MergeTemplate<E>{

        public MergeSubtract (PositionList<E> A , PositionList<E> B, Comparator<E> c){
            super(A,B,c);
        }

        @Override
        protected void aIsLess(E a) {
            s.addLast(a);
        }

        @Override
        protected void bIsLess(E b) {

        }

        @Override
        protected void bothAreEqual(E a, E b) {

        }
    }





}