sequenceiterator.java

来自「java 的源代码」· Java 代码 · 共 238 行

package com.reddragon2046.base.utilities.data;

import java.util.*;

// Referenced classes of package com.reddragon2046.base.utilities.data:
//            RandomAccessIterator, Opaque, Sequence, ForwardIterator,
//            Container, InputIterator

class SequenceIterator
    implements RandomAccessIterator
{

    SequenceIterator(Sequence sequence)
    {
        this(sequence, 0);
    }

    SequenceIterator(Sequence sequence, int index)
    {
        m_lastIndex = -1;
        m_index = index;
        m_sequence = sequence;
        m_lastDirection = 0;
    }

    SequenceIterator(SequenceIterator copy)
    {
        m_lastIndex = -1;
        m_index = copy.m_index;
        m_lastDirection = copy.m_lastDirection;
        m_lastIndex = copy.m_lastIndex;
        m_sequence = copy.m_sequence;
    }

    public boolean hasPrevious()
    {
        return !atBegin();
    }

    public Object previous()
    {
        retreat();
        return get();
    }

    public int index()
    {
        return m_index;
    }

    public boolean less(RandomAccessIterator iter)
    {
        return m_index < iter.index();
    }

    public void remove()
    {
        if(m_lastIndex == -1)
            throw new IllegalStateException();
        m_sequence.remove(m_lastIndex);
        if(m_lastIndex < m_index)
            m_index--;
        m_lastIndex = -1;
    }

    public void retreat()
    {
        retreat(1);
    }

    public void retreat(int n)
    {
        m_index -= n;
        m_lastDirection = -1;
    }

    public void advance()
    {
        advance(1);
    }

    public void advance(int n)
    {
        m_index += n;
        m_lastDirection = 1;
    }

    public Object get(int offset)
    {
        try
        {
            Object obj = m_sequence.get(m_index + offset);
            m_lastIndex = m_index + offset;
            return obj;
        }
        catch(RuntimeException ex)
        {
            throw new NoSuchElementException(ex.getMessage());
        }
    }

    public void put(int offset, Object object)
    {
        try
        {
            m_sequence.set(m_index + offset, object);
        }
        catch(RuntimeException ex)
        {
            throw new NoSuchElementException(ex.getMessage());
        }
    }

    public boolean equals(Object object)
    {
        if(object instanceof RandomAccessIterator)
        {
            RandomAccessIterator iter = (RandomAccessIterator)object;
            return isCompatibleWith(iter) && index() == iter.index();
        } else
        {
            return false;
        }
    }

    public int distance(ForwardIterator iterator)
    {
        return (iterator instanceof RandomAccessIterator) ? ((RandomAccessIterator)iterator).index() - index() : 0;
    }

    public Container getContainer()
    {
        return m_sequence;
    }

    public Collection getCollection()
    {
        return m_sequence;
    }

    public Object clone()
    {
        return new SequenceIterator(this);
    }

    public boolean atBegin()
    {
        return m_index == 0;
    }

    public boolean atEnd()
    {
        return m_index == m_sequence.size();
    }

    public boolean hasNext()
    {
        return !atEnd();
    }

    public Object get()
    {
        return get(0);
    }

    public void put(Object object)
    {
        put(0, object);
    }

    public Object next()
    {
        Object obj = get();
        advance(1);
        return obj;
    }

    public boolean isCompatibleWith(InputIterator iterator)
    {
        return opaqueId() == iterator.opaqueId();
    }

    public int distance(InputIterator iterator)
    {
        if(!isCompatibleWith(iterator))
            throw new IllegalArgumentException("iterators not compatible");
        else
            return ((SequenceIterator)iterator).m_index - index();
    }

    public Object opaqueData()
    {
        return new Integer(index());
    }

    public int opaqueId()
    {
        return System.identityHashCode(getContainer());
    }

    public void add(Object obj)
    {
        m_sequence.add(m_index, obj);
        if(m_lastIndex >= m_index)
            m_lastIndex++;
    }

    public int nextIndex()
    {
        return m_index;
    }

    public int previousIndex()
    {
        return m_index - 1;
    }

    public void set(Object obj)
    {
        if(m_lastIndex == -1)
        {
            throw new NoSuchElementException();
        } else
        {
            m_sequence.set(m_lastIndex, obj);
            return;
        }
    }

    private int m_index;
    private int m_lastIndex;
    private int m_lastDirection;
    private Sequence m_sequence;
    private static final int STATIONARY = 0;
    private static final int FORWARD = 1;
    private static final int BACK = -1;
}