setoperations.java

java 的源代码

package com.reddragon2046.base.utilities.data.algorithms;

import com.reddragon2046.base.utilities.data.BinaryPredicate;
import com.reddragon2046.base.utilities.data.OutputIterator;
import com.reddragon2046.base.utilities.data.predicates.LessEqualPredicate;
import com.reddragon2046.base.utilities.data.predicates.LessPredicate;
import com.reddragon2046.base.utilities.data.util.CollectionFactory;
import com.reddragon2046.base.utilities.data.util.InsertIterator;
import java.util.*;

// Referenced classes of package com.reddragon2046.base.utilities.data.algorithms:
//            OrderedSetOperations

public final class SetOperations
{
    private static final class Params
    {

        public Collection getSet1()
        {
            return m_set1;
        }

        public Collection getSet2()
        {
            return m_set2;
        }

        public BinaryPredicate getSortPredicate()
        {
            return m_sortPredicate;
        }

        private Collection m_set1;
        private Collection m_set2;
        private BinaryPredicate m_sortPredicate;

        public Params(Collection set1, Collection set2)
        {
            if(SetOperations.areSortCompatible(set1, set2))
            {
                Comparator comparator = ((SortedSet)set1).comparator();
                if(comparator != null)
                    m_sortPredicate = new LessPredicate(comparator);
                else
                    m_sortPredicate = new LessPredicate();
                m_set1 = set1;
                m_set2 = set2;
            } else
            {
                m_set1 = SetOperations.getSortedList(set1);
                m_set2 = SetOperations.getSortedList(set2);
                m_sortPredicate = new LessPredicate();
            }
        }
    }


    public SetOperations()
    {
    }

    public static boolean isSuperset(Collection set1, Collection set2, BinaryPredicate comparator)
    {
        return OrderedSetOperations.isSuperset(set1, set2, comparator);
    }

    public static boolean isSuperset(Collection set1, Collection set2)
    {
        Params params = new Params(set1, set2);
        return OrderedSetOperations.isSuperset(params.getSet1(), params.getSet2(), params.getSortPredicate());
    }

    private static boolean areSortCompatible(Collection collection1, Collection collection2)
    {
        boolean compatible = false;
        if((collection1 instanceof SortedSet) && (collection2 instanceof SortedSet))
        {
            Comparator comparator1 = ((SortedSet)collection1).comparator();
            Comparator comparator2 = ((SortedSet)collection2).comparator();
            if(comparator1 == null && comparator2 == null)
                compatible = true;
            else
            if(comparator1 != null && comparator1.equals(comparator2))
                compatible = true;
        }
        return compatible;
    }

    private static Comparator getComparatorIfSorted(Collection collection1, Collection collection2)
    {
        Comparator sortedComparator = null;
        if(areSortCompatible(collection1, collection2))
        {
            Comparator comparator1 = ((SortedSet)collection1).comparator();
            sortedComparator = comparator1;
        }
        return sortedComparator;
    }

    public static OutputIterator setUnion(Collection set1, Collection set2, OutputIterator result, BinaryPredicate sortPredicate)
    {
        return OrderedSetOperations.setUnion(set1, set2, result, sortPredicate);
    }

    public static Collection setUnion(Collection set1, Collection set2)
    {
        Collection result = getResultCollection(set1.getClass());
        setUnion(set1, set2, ((OutputIterator) (new InsertIterator(result))));
        return result;
    }

    public static OutputIterator setUnion(Collection set1, Collection set2, OutputIterator result)
    {
        Params params = new Params(set1, set2);
        return setUnion(params.getSet1(), params.getSet2(), result, params.getSortPredicate());
    }

    public static Collection setUnion(Collection collection1, Collection collection2, BinaryPredicate comparator)
    {
        Collection result = getResultCollection(collection1.getClass());
        setUnion(collection1, collection2, ((OutputIterator) (new InsertIterator(result))), comparator);
        return result;
    }

    public static OutputIterator setIntersection(Collection collection1, Collection collection2, OutputIterator result, BinaryPredicate comparator)
    {
        return OrderedSetOperations.setIntersection(collection1, collection2, result, comparator);
    }

    public static Collection setIntersection(Collection collection1, Collection collection2)
    {
        Collection result = getResultCollection(collection1.getClass());
        setIntersection(collection1, collection2, ((OutputIterator) (new InsertIterator(result))));
        return result;
    }

    public static Collection setIntersection(Collection collection1, Collection collection2, BinaryPredicate comparator)
    {
        Collection result = getResultCollection(collection1.getClass());
        setIntersection(collection1, collection2, ((OutputIterator) (new InsertIterator(result))), comparator);
        return result;
    }

    public static OutputIterator setIntersection(Collection set1, Collection set2, OutputIterator result)
    {
        Params params = new Params(set1, set2);
        return setIntersection(params.getSet1(), params.getSet2(), result, params.getSortPredicate());
    }

    public static OutputIterator setDifference(Collection set1, Collection set2, OutputIterator result, BinaryPredicate sortPredicate)
    {
        return OrderedSetOperations.setDifference(set1, set2, result, sortPredicate);
    }

    public static Collection setDifference(Collection set1, Collection set2)
    {
        Collection result = getResultCollection(set1.getClass());
        setDifference(set1, set2, ((OutputIterator) (new InsertIterator(result))));
        return result;
    }

    public static OutputIterator setDifference(Collection set1, Collection set2, OutputIterator result)
    {
        Params params = new Params(set1, set2);
        return setDifference(params.getSet1(), params.getSet2(), result, params.getSortPredicate());
    }

    public static OutputIterator setSymmetricDifference(Collection set1, Collection set2, OutputIterator result, BinaryPredicate sortPredicate)
    {
        return OrderedSetOperations.setSymmetricDifference(set1, set2, result, sortPredicate);
    }

    public static Collection setSymmetricDifference(Collection set1, Collection set2)
    {
        Collection result = getResultCollection(set1.getClass());
        setSymmetricDifference(set1, set2, ((OutputIterator) (new InsertIterator(result))));
        return result;
    }

    public static OutputIterator setSymmetricDifference(Collection set1, Collection set2, OutputIterator result)
    {
        Params params = new Params(set1, set2);
        return setSymmetricDifference(params.getSet1(), params.getSet2(), result, params.getSortPredicate());
    }

    public static Collection setSymmetricDifference(Collection collection1, Collection collection2, BinaryPredicate comparator)
    {
        Collection result = getResultCollection(collection1.getClass());
        setSymmetricDifference(collection1, collection2, ((OutputIterator) (new InsertIterator(result))), comparator);
        return result;
    }

    private static List getSortedList(Collection c)
    {
        LinkedList list = new LinkedList(c);
        Collections.sort(list);
        return list;
    }

    private static Collection getResultCollection(Class collectionClass)
    {
        return CollectionFactory.create(collectionClass);
    }

    private static BinaryPredicate getCheckedComparator(BinaryPredicate comparator)
    {
        if(comparator == null)
            return new LessEqualPredicate();
        else
            return comparator;
    }


}