filtering.java

java 的源代码

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

import com.reddragon2046.base.utilities.data.*;
import com.reddragon2046.base.utilities.data.predicates.UnaryNot;
import com.reddragon2046.base.utilities.data.util.*;
import java.util.*;

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

public final class Filtering
{

    private Filtering()
    {
    }

    public static OutputIterator unique(Container container)
    {
        return unique(container.start(), container.finish(), ((BinaryPredicate) (new Predicates.EqualTo())));
    }

    public static OutputIterator unique(List list)
    {
        return unique(((ForwardIterator) (IteratorFactory.start(list))), ((ForwardIterator) (IteratorFactory.finish(list))), ((BinaryPredicate) (new Predicates.EqualTo())));
    }

    private static OutputIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate predicate)
    {
        first = (ForwardIterator)Finding.adjacentFind(first, last, predicate);
        return uniqueCopy(first, last, first, predicate);
    }

    public static OutputIterator unique(Container container, BinaryPredicate predicate)
    {
        return unique(container.start(), container.finish(), predicate);
    }

    public static OutputIterator unique(List list, BinaryPredicate predicate)
    {
        return unique(((ForwardIterator) (IteratorFactory.start(list))), ((ForwardIterator) (IteratorFactory.finish(list))), predicate);
    }

    public static OutputIterator uniqueCopy(Collection collection, OutputIterator result)
    {
        return uniqueCopy(IteratorFactory.start(collection), IteratorFactory.finish(collection), result, ((BinaryPredicate) (new Predicates.EqualTo())));
    }

    public static void uniqueCopy(Collection source, Collection destination)
    {
        uniqueCopy(IteratorFactory.start(source), IteratorFactory.finish(source), ((OutputIterator) (new InsertIterator(destination))), ((BinaryPredicate) (new Predicates.EqualTo())));
    }

    public static Collection uniqueCopy(Collection source)
    {
        Vector dest = new Vector(source.size());
        uniqueCopy(source, ((Collection) (dest)));
        return dest;
    }

    private static OutputIterator uniqueCopy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate predicate)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        InputIterator firstx = (InputIterator)first.clone();
        if(firstx.equals(last))
            return (OutputIterator)result.clone();
        if(result instanceof ForwardIterator)
        {
            ForwardIterator resultx = (ForwardIterator)result.clone();
            resultx.put(firstx.next());
            for(; !firstx.equals(last); firstx.advance())
                if(!predicate.execute(resultx.get(), firstx.get()))
                {
                    resultx.advance();
                    resultx.put(firstx.get());
                }

            resultx.advance();
            return resultx;
        }
        Object value = firstx.get();
        OutputIterator resultx = (OutputIterator)result.clone();
        resultx.put(value);
        firstx.advance();
        for(; !firstx.equals(last); firstx.advance())
            if(!predicate.execute(value, firstx.get()))
            {
                value = firstx.get();
                resultx.advance();
                resultx.put(value);
            }

        resultx.advance();
        return resultx;
    }

    public static OutputIterator uniqueCopy(Collection collection, OutputIterator result, BinaryPredicate predicate)
    {
        return uniqueCopy(IteratorFactory.start(collection), IteratorFactory.finish(collection), result, predicate);
    }

    public static void uniqueCopy(Collection source, Collection destination, BinaryPredicate predicate)
    {
        uniqueCopy(IteratorFactory.start(source), IteratorFactory.finish(source), ((OutputIterator) (new InsertIterator(destination))), predicate);
    }

    public static Collection select(Collection collection, UnaryPredicate predicate)
    {
        Collection selection = CollectionFactory.create(collection.getClass());
        InputIterator start = IteratorFactory.start(collection);
        InputIterator finish = IteratorFactory.finish(collection);
        return select(start, finish, predicate, selection);
    }

    public static Collection reject(Collection collection, UnaryPredicate predicate)
    {
        return select(collection, new UnaryNot(predicate));
    }

    private static Collection select(InputIterator first, InputIterator last, UnaryPredicate predicate, Collection collection)
    {
        if(!first.isCompatibleWith(last))
            throw new IllegalArgumentException("iterators not compatible");
        collection.clear();
        for(InputIterator firstx = (InputIterator)first.clone(); !firstx.equals(last);)
        {
            Object object = firstx.next();
            if(predicate.execute(object))
                collection.add(object);
        }

        return collection;
    }

    private static final BinaryPredicate DEFAULT_PREDICATE = new Predicates.EqualTo();

}