dequeiterator.java

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

package com.reddragon2046.base.utilities.data;

import java.io.PrintStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.NoSuchElementException;

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

public final class DequeIterator
    implements RandomAccessIterator, Serializable
{
    private static class DequeInfo
    {

        int block;
        int map;
        boolean isInvalid;

        DequeInfo(DequeIterator iter)
        {
            block = iter.myBlock;
            map = iter.myMap;
            isInvalid = iter.myDeque == null;
        }
    }


    DequeIterator(Deque deque, int blockIndex, int mapIndex)
    {
        myDeque = deque;
        myBlock = blockIndex;
        myMap = mapIndex;
        lastBlock = -1;
        lastMap = -1;
    }

    public DequeIterator()
    {
        this(null, -1, -1);
    }

    public DequeIterator(DequeIterator iterator)
    {
        myDeque = iterator.myDeque;
        myBlock = iterator.myBlock;
        myMap = iterator.myMap;
        lastBlock = -1;
        lastMap = -1;
    }

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

    public boolean equals(Object object)
    {
        if(object instanceof DequeIterator)
        {
            DequeIterator iterator = (DequeIterator)object;
            return myDeque != null && myDeque == iterator.myDeque && myMap == iterator.myMap && myBlock == iterator.myBlock;
        }
        if(object instanceof Opaque)
        {
            DequeInfo info = (DequeInfo)((Opaque)object).opaqueData();
            return myDeque != null && myMap == info.map && myBlock == info.block && isCompatibleWith((InputIterator)object);
        } else
        {
            return false;
        }
    }

    public int hashCode()
    {
        return System.identityHashCode(myDeque) ^ myBlock;
    }

    public boolean atBegin()
    {
        return equals(myDeque.myStart);
    }

    public boolean atEnd()
    {
        return equals(myDeque.myFinish);
    }

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

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

    public void advance()
    {
        if(myDeque == null || equals(myDeque.myFinish))
            throw new NoSuchElementException("DequeIterator");
        if(++myBlock == 128)
        {
            myMap++;
            myBlock = 0;
        }
    }

    public void advance(int n)
    {
        if(myDeque == null || n > 0 && equals(myDeque.myFinish) || n < 0 && equals(myDeque.myStart))
            throw new NoSuchElementException("DequeIterator");
        int b = myBlock;
        int m = myMap;
        b += n;
        if(b >= 128)
        {
            int jump = b / 128;
            m += jump;
            b %= 128;
        } else
        if(b < 0)
        {
            int jump = (127 - b) / 128;
            m -= jump;
            b += jump * 128;
        }
        int i = myDeque.myStart.calcDistance(b, m);
        if(i < 0 || i > myDeque.size())
        {
            throw new NoSuchElementException("DequeIterator");
        } else
        {
            myBlock = b;
            myMap = m;
            return;
        }
    }

    public void retreat()
    {
        if(myDeque == null || equals(myDeque.myStart))
            throw new NoSuchElementException("DequeIterator");
        if(--myBlock == -1)
        {
            myMap--;
            myBlock = 127;
        }
    }

    public void retreat(int n)
    {
        advance(-n);
    }

    public Object next()
    {
        if(myDeque == null || equals(myDeque.myFinish))
        {
            throw new NoSuchElementException("DequeIterator");
        } else
        {
            lastMap = myMap;
            lastBlock = myBlock;
            advance();
            return myDeque.myMap[lastMap][lastBlock];
        }
    }

    public Object previous()
    {
        if(myDeque == null || equals(myDeque.myStart))
        {
            throw new NoSuchElementException("DequeIterator");
        } else
        {
            retreat();
            return get();
        }
    }

    public Object get()
    {
        if(myDeque == null || equals(myDeque.myFinish))
        {
            throw new NoSuchElementException("DequeIterator");
        } else
        {
            lastMap = myMap;
            lastBlock = myBlock;
            return myDeque.myMap[myMap][myBlock];
        }
    }

    public Object get(int offset)
    {
        DequeIterator iter = copy(offset);
        lastMap = iter.myMap;
        lastBlock = iter.myBlock;
        return iter.get();
    }

    public void put(Object object)
    {
        if(myDeque == null || equals(myDeque.myFinish))
        {
            throw new NoSuchElementException("DequeIterator");
        } else
        {
            myDeque.myMap[myMap][myBlock] = object;
            return;
        }
    }

    public void put(int offset, Object object)
    {
        copy(offset).put(object);
    }

    public int distance(InputIterator iter)
    {
        if(!isCompatibleWith(iter))
            throw new IllegalArgumentException("iterators not compatible");
        if(myDeque == null)
            throw new NoSuchElementException("DequeIterator");
        DequeInfo info = (DequeInfo)iter.opaqueData();
        if(info.isInvalid)
            throw new NoSuchElementException("DequeIterator");
        else
            return calcDistance(info.block, info.map);
    }

    public int index()
    {
        if(myDeque == null)
            throw new NoSuchElementException("DequeIterator");
        else
            return myDeque.myStart.calcDistance(myBlock, myMap);
    }

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

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

    public void add(Object object)
    {
        if(myDeque == null)
        {
            throw new NoSuchElementException("DequeIterator");
        } else
        {
            DequeIterator iter = myDeque.insert(this, object);
            myBlock = iter.myBlock;
            myMap = iter.myMap;
            return;
        }
    }

    public void set(Object object)
    {
        if(myDeque == null || lastMap < 0)
        {
            throw new IllegalStateException("DequeIterator");
        } else
        {
            myDeque.myMap[lastMap][lastBlock] = object;
            return;
        }
    }

    public void remove()
    {
        if(myDeque == null || lastMap < 0)
            throw new IllegalStateException();
        myDeque.removeFrom(new DequeIterator(myDeque, lastBlock, lastMap));
        if(myDeque.size() == 0)
        {
            myBlock = myDeque.myFinish.myBlock;
            myMap = myDeque.myFinish.myMap;
        } else
        if(lastMap < myMap || lastMap == myMap && lastBlock < myBlock)
            retreat();
        lastMap = -1;
    }

    public boolean less(RandomAccessIterator iterator)
    {
        if(!isCompatibleWith(iterator))
            throw new IllegalArgumentException("iterators not compatible");
        if(myDeque == null)
            throw new NoSuchElementException("DequeIterator");
        DequeInfo info = (DequeInfo)iterator.opaqueData();
        if(info.isInvalid)
            throw new NoSuchElementException("DequeIterator");
        else
            return myMap < info.map || myMap == info.map && myBlock < info.block;
    }

    public Container getContainer()
    {
        return myDeque;
    }

    public Collection getCollection()
    {
        return myDeque;
    }

    public boolean isCompatibleWith(InputIterator iterator)
    {
        return myDeque != null && opaqueId() == iterator.opaqueId();
    }

    public Object opaqueData()
    {
        return new DequeInfo(this);
    }

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

    final DequeIterator copy(int i)
    {
        DequeIterator tmp = new DequeIterator(this);
        tmp.advance(i);
        return tmp;
    }

    final int calcDistance(int block, int map)
    {
        int gap = block - myBlock;
        return myMap != map ? 128 * (map - myMap) + gap : gap;
    }

    public void dump()
    {
        System.out.print("\tmap==" + myMap);
        System.out.print("\tblock==" + myBlock);
        System.out.print("\tlastmap==" + lastMap);
        System.out.print("\tlastblock==" + lastBlock);
        System.out.println();
    }

    Deque myDeque;
    int myBlock;
    int myMap;
    int lastBlock;
    int lastMap;
    static final long serialVersionUID = 0x71c36d5d3debf406L;
}