orderedsetoperations.java

java 的源代码

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

import com.reddragon2046.base.utilities.data.*;
import com.reddragon2046.base.utilities.data.predicates.LessEqualPredicate;
import com.reddragon2046.base.utilities.data.util.IteratorFactory;
import java.util.Collection;
import java.util.Comparator;

// Referenced classes of package com.reddragon2046.base.utilities.data.algorithms:
//            Predicates, Copying

final class OrderedSetOperations
{

    private OrderedSetOperations()
    {
    }

    public static boolean isSuperset(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2)
    {
        return isSuperset(first1, last1, first2, last2, ((BinaryPredicate) (new LessEqualPredicate())));
    }

    public static boolean isSuperset(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, Comparator comparator)
    {
        return isSuperset(first1, last1, first2, last2, ((BinaryPredicate) (new LessEqualPredicate(comparator))));
    }

    public static boolean isSuperset(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, BinaryPredicate comparator)
    {
        if(comparator == null)
            comparator = new LessEqualPredicate();
        InputIterator first1x = (InputIterator)first1.clone();
        InputIterator first2x;
        for(first2x = (InputIterator)first2.clone(); !first1x.equals(last1) && !first2x.equals(last2);)
        {
            if(comparator.execute(first2x.get(), first1x.get()))
                return false;
            if(comparator.execute(first1x.get(), first2x.get()))
            {
                first1x.advance();
            } else
            {
                first1x.advance();
                first2x.advance();
            }
        }

        return first2x.equals(last2);
    }

    public static boolean isSuperset(Collection collection1, Collection collection2, BinaryPredicate comparator)
    {
        return isSuperset(IteratorFactory.start(collection1), IteratorFactory.finish(collection1), IteratorFactory.start(collection2), IteratorFactory.finish(collection2), comparator);
    }

    public static boolean isSuperset(Collection collection1, Collection collection2)
    {
        return isSuperset(collection1, collection2, ((BinaryPredicate) (new LessEqualPredicate())));
    }

    public static boolean isSuperset(Collection collection1, Collection collection2, Comparator comparator)
    {
        return isSuperset(collection1, collection2, ((BinaryPredicate) (new LessEqualPredicate(comparator))));
    }

    public static OutputIterator setUnion(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result)
    {
        return setUnion(first1, last1, first2, last2, result, ((BinaryPredicate) (new Predicates.HashComparator())));
    }

    public static OutputIterator setUnion(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result, BinaryPredicate comparator)
    {
        InputIterator first1x = (InputIterator)first1.clone();
        InputIterator first2x = (InputIterator)first2.clone();
        OutputIterator resultx = (OutputIterator)result.clone();
        while(!first1x.equals(last1) && !first2x.equals(last2))
            if(comparator.execute(first1x.get(), first2x.get()))
            {
                resultx.put(first1x.get());
                resultx.advance();
                first1x.advance();
            } else
            if(comparator.execute(first2x.get(), first1x.get()))
            {
                resultx.put(first2x.get());
                resultx.advance();
                first2x.advance();
            } else
            {
                resultx.put(first1x.get());
                resultx.advance();
                first1x.advance();
                first2x.advance();
            }
        return Copying.copy(first2x, last2, Copying.copy(first1x, last1, resultx));
    }

    public static OutputIterator setUnion(Collection collection1, Collection collection2, OutputIterator result, BinaryPredicate comparator)
    {
        return setUnion(IteratorFactory.start(collection1), IteratorFactory.finish(collection1), IteratorFactory.start(collection2), IteratorFactory.finish(collection2), result, comparator);
    }

    public static OutputIterator setIntersection(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result)
    {
        return setIntersection(first1, last1, first2, last2, result, ((BinaryPredicate) (new Predicates.HashComparator())));
    }

    public static OutputIterator setIntersection(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result, BinaryPredicate comparator)
    {
        InputIterator first1x = (InputIterator)first1.clone();
        InputIterator first2x = (InputIterator)first2.clone();
        OutputIterator resultx = (OutputIterator)result.clone();
        while(!first1x.equals(last1) && !first2x.equals(last2))
            if(comparator.execute(first1x.get(), first2x.get()))
                first1x.advance();
            else
            if(comparator.execute(first2x.get(), first1x.get()))
            {
                first2x.advance();
            } else
            {
                resultx.put(first1x.get());
                resultx.advance();
                first1x.advance();
                first2x.advance();
            }
        return resultx;
    }

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

    public static OutputIterator setDifference(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result)
    {
        return setDifference(first1, last1, first2, last2, result, ((BinaryPredicate) (new Predicates.HashComparator())));
    }

    public static OutputIterator setDifference(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result, BinaryPredicate comparator)
    {
        InputIterator first1x = (InputIterator)first1.clone();
        InputIterator first2x = (InputIterator)first2.clone();
        OutputIterator resultx = (OutputIterator)result.clone();
        while(!first1x.equals(last1) && !first2x.equals(last2))
            if(comparator.execute(first1x.get(), first2x.get()))
            {
                resultx.put(first1x.get());
                resultx.advance();
                first1x.advance();
            } else
            if(comparator.execute(first2x.get(), first1x.get()))
            {
                first2x.advance();
            } else
            {
                first1x.advance();
                first2x.advance();
            }
        return Copying.copy(first1x, last1, resultx);
    }

    public static OutputIterator setDifference(Collection collection1, Collection collection2, OutputIterator result, BinaryPredicate sortPredicate)
    {
        return setDifference(IteratorFactory.start(collection1), IteratorFactory.finish(collection1), IteratorFactory.start(collection2), IteratorFactory.finish(collection2), result, sortPredicate);
    }

    public static OutputIterator setSymmetricDifference(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result)
    {
        return setSymmetricDifference(first1, last1, first2, last2, result, ((BinaryPredicate) (new Predicates.HashComparator())));
    }

    public static OutputIterator setSymmetricDifference(InputIterator first1, InputIterator last1, InputIterator first2, InputIterator last2, OutputIterator result, BinaryPredicate comparator)
    {
        InputIterator first1x = (InputIterator)first1.clone();
        InputIterator first2x = (InputIterator)first2.clone();
        OutputIterator resultx = (OutputIterator)result.clone();
        while(!first1x.equals(last1) && !first2x.equals(last2))
            if(comparator.execute(first1x.get(), first2x.get()))
            {
                resultx.put(first1x.get());
                resultx.advance();
                first1x.advance();
            } else
            if(comparator.execute(first2x.get(), first1x.get()))
            {
                resultx.put(first2x.get());
                resultx.advance();
                first2x.advance();
            } else
            {
                first1x.advance();
                first2x.advance();
            }
        return Copying.copy(first2x, last2, Copying.copy(first1x, last1, resultx));
    }

    public static OutputIterator setSymmetricDifference(Collection collection1, Collection collection2, OutputIterator result, BinaryPredicate comparator)
    {
        return setSymmetricDifference(IteratorFactory.start(collection1), IteratorFactory.finish(collection1), IteratorFactory.start(collection2), IteratorFactory.finish(collection2), result, comparator);
    }
}