abstractindexbasediterator.java

java 的源代码

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

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

// Referenced classes of package com.reddragon2046.base.utilities.data.collections:
//            IterationState

abstract class AbstractIndexBasedIterator
    implements IndexBased
{

    public abstract void advance();

    public abstract void retreat();

    protected AbstractIndexBasedIterator(IterationState data)
    {
        m_data = data;
    }

    public String toString()
    {
        return m_data.toString();
    }

    public boolean atBegin()
    {
        return m_data.getAtBegin();
    }

    public boolean atEnd()
    {
        return m_data.getAtEnd();
    }

    public Object get()
    {
        return m_data.getObject();
    }

    public void advance(int n)
    {
        for(int i = 0; i < n; i++)
            advance();

    }

    public void retreat(int n)
    {
        for(int i = 0; i < n; i++)
            retreat();

    }

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

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

    public Object next()
    {
        Object object = null;
        if(!atEnd())
            object = get();
        else
            throw new NoSuchElementException();
        advance();
        return object;
    }

    public void remove()
    {
        if(m_data.getObject() == null)
        {
            throw new IllegalStateException();
        } else
        {
            m_data.getIterator().remove();
            m_data.setObject(null);
            return;
        }
    }

    public Container getContainer()
    {
        throw new UnsupportedOperationException("Cannot get container from a non-JGL iterator adapter");
    }

    public Collection getCollection()
    {
        return m_data.getCollection();
    }

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

    public int opaqueId()
    {
        return getClass().getName().hashCode() + System.identityHashCode(m_data.getCollection());
    }

    public Object opaqueData()
    {
        return ((Object) (new Object[] {
            m_data.getIterator(), m_data.getCollection(), new Integer(m_data.getIndex())
        }));
    }

    public boolean equals(Object object)
    {
        boolean isEqual = false;
        if(object instanceof AbstractIndexBasedIterator)
        {
            AbstractIndexBasedIterator other = (AbstractIndexBasedIterator)object;
            if(other.getCollection() == getCollection())
                if(other.atBegin() && other.atEnd() && atBegin() && atEnd())
                    isEqual = true;
                else
                    isEqual = other.m_data.getIndex() == m_data.getIndex();
        }
        return isEqual;
    }

    public int getIndex()
    {
        return getInternalIndex() + 1;
    }

    protected int getInternalIndex()
    {
        return m_data.getIndex();
    }

    protected Iterator getInternalIterator()
    {
        return m_data.getIterator();
    }

    protected IterationState getIterationData()
    {
        return m_data;
    }

    private IterationState m_data;
}