iteratorfactory.java

java 的源代码

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

import com.reddragon2046.base.utilities.data.*;
import com.reddragon2046.base.utilities.data.collections.*;
import java.util.*;

public class IteratorFactory
{

    public IteratorFactory()
    {
    }

    public static InputIterator start(Collection c)
    {
        if(c instanceof Container)
            return ((Container)c).start();
        if(c instanceof Series)
            return ((Series)c).startInput();
        if(c instanceof List)
            return ForwardIteratorAdapter.start((List)c);
        else
            return InputIteratorAdapter.start(c);
    }

    public static InputIterator finish(Collection c)
    {
        if(c instanceof Container)
            return ((Container)c).finish();
        if(c instanceof Series)
            return ((Series)c).finishInput();
        if(c instanceof List)
            return ForwardIteratorAdapter.finish((List)c);
        else
            return InputIteratorAdapter.finish(c);
    }

    public static ForwardIterator startForward(List list)
    {
        if(list instanceof Container)
            return startForward((Container)list);
        if(list instanceof ModifiableSeries)
            return ((ModifiableSeries)list).startForward();
        else
            return ForwardIteratorAdapter.start(list);
    }

    public static ForwardIterator finishForward(List list)
    {
        if(list instanceof Container)
            return finishForward((Container)list);
        if(list instanceof ModifiableSeries)
            return ((ModifiableSeries)list).finishForward();
        else
            return ForwardIteratorAdapter.finish(list);
    }

    public static ForwardIterator startForward(Container c)
    {
        return c.start();
    }

    public static ForwardIterator finishForward(Container c)
    {
        return c.finish();
    }

    public static BidirectionalIterator start(List list)
    {
        if(list instanceof Sequence)
        {
            Sequence seq = (Sequence)list;
            ForwardIterator iter = seq.start();
            if(!(iter instanceof BidirectionalIterator))
                throw new RuntimeException("Sequence iterators must be bidirectional");
            else
                return (BidirectionalIterator)iter;
        } else
        {
            return BidirectionalIteratorAdapter.startBidirectional(list);
        }
    }

    public static BidirectionalIterator finish(List list)
    {
        if(list instanceof Sequence)
        {
            Sequence seq = (Sequence)list;
            ForwardIterator iter = seq.finish();
            if(iter instanceof BidirectionalIterator)
                return (BidirectionalIterator)iter;
        }
        return BidirectionalIteratorAdapter.finishBidirectional(list);
    }

    public static BidirectionalIterator startAt(List list, int index)
    {
        BidirectionalIterator iter = start(list);
        iter.advance(index);
        return iter;
    }

    public static BidirectionalIterator finishAt(List list, int index)
    {
        BidirectionalIterator iter = start(list);
        iter.advance(index + 1);
        return iter;
    }

    public static InputIterator startAt(Collection c, int index)
    {
        InputIterator iter = start(c);
        iter.advance(index);
        return iter;
    }

    public static InputIterator finishAt(Collection list, int index)
    {
        return startAt(list, index + 1);
    }

    public static ForwardIterator startForwardAt(List list, int index)
    {
        ForwardIterator iter = null;
        if(list instanceof Container)
        {
            Container c = (Container)list;
            iter = c.start();
            iter.advance(index);
        } else
        {
            iter = startForward(list);
            iter.advance(index);
        }
        return iter;
    }

    public static ForwardIterator finishForwardAt(List list, int index)
    {
        return startForwardAt(list, index + 1);
    }

    public static InputIterator start(Map map)
    {
        return start(((Collection) (map.entrySet())));
    }

    public static InputIterator finish(Map map)
    {
        return finish(((Collection) (map.entrySet())));
    }
}