abstractarrayiterator.java

java 的源代码

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

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

public abstract class AbstractArrayIterator
    implements RandomAccessIterator
{

    public abstract boolean isCompatibleWith(InputIterator inputiterator);

    public abstract Object clone();

    public abstract Object get(int i);

    protected AbstractArrayIterator(Container container)
    {
        this(container, 0);
    }

    protected AbstractArrayIterator(Container container, int index)
    {
        m_container = container;
        m_index = index;
        m_lastMove = 0;
    }

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

    public void advance(int n)
    {
        incrementIndex(n);
    }

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

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

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

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

    public int index()
    {
        return getInternalIndex();
    }

    public boolean less(RandomAccessIterator iterator)
    {
        return m_index < ((AbstractArrayIterator)iterator).getInternalIndex();
    }

    public int opaqueId()
    {
        return getClass().getName().hashCode();
    }

    public Object opaqueData()
    {
        return ((Object) (new Object[] {
            m_container, new Integer(m_index)
        }));
    }

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

    public void retreat(int n)
    {
        decrementIndex(n);
    }

    public Container getContainer()
    {
        return m_container;
    }

    public Collection getCollection()
    {
        return m_container;
    }

    public void add(Object obj)
    {
        throw new UnsupportedOperationException("add not supported on native arrays");
    }

    public boolean hasNext()
    {
        return m_index < m_container.size();
    }

    public boolean hasPrevious()
    {
        return m_index > 0;
    }

    public Object next()
    {
        try
        {
            Object obj = get();
            advance();
            return obj;
        }
        catch(IndexOutOfBoundsException indexoutofboundsexception)
        {
            throw new NoSuchElementException(getClass().getName());
        }
    }

    public int nextIndex()
    {
        return m_index;
    }

    public Object previous()
    {
        try
        {
            retreat();
            return get();
        }
        catch(IndexOutOfBoundsException indexoutofboundsexception)
        {
            throw new NoSuchElementException("call to previous on " + getClass().getName());
        }
    }

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

    public void remove()
    {
        throw new UnsupportedOperationException("remove not supported on native arrays");
    }

    public void set(Object object)
    {
        if(m_lastMove > 0)
            put(-1, object);
        else
        if(m_lastMove < 0)
            put(0, object);
        else
            throw new IllegalStateException();
    }

    protected final int getInternalIndex()
    {
        return m_index;
    }

    protected final void incrementIndex()
    {
        incrementIndex(1);
    }

    protected final void incrementIndex(int n)
    {
        m_index += n;
        m_lastMove = n;
    }

    protected final void decrementIndex()
    {
        decrementIndex(1);
    }

    protected final void decrementIndex(int n)
    {
        m_index -= n;
        m_lastMove = -1 * n;
    }

    public abstract void put(int i, Object obj);

    public abstract void put(Object obj);

    private Container m_container;
    private int m_index;
    private int m_lastMove;
}