booleaniterator.java

java 的源代码

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

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

// Referenced classes of package com.reddragon2046.base.utilities.data.adapters:
//            AbstractArrayIterator, BooleanArray, BooleanBuffer, ByteBuffer

public final class BooleanIterator extends AbstractArrayIterator
    implements RandomAccessIterator, Serializable
{

    public static BooleanIterator begin(boolean array[])
    {
        return new BooleanIterator(array, 0);
    }

    public static BooleanIterator end(boolean array[])
    {
        return new BooleanIterator(array, array.length);
    }

    public BooleanIterator()
    {
        this(new BooleanArray(), 0);
    }

    public BooleanIterator(BooleanIterator iterator)
    {
        super(iterator.getContainer(), iterator.getInternalIndex());
        offset = iterator.offset;
    }

    BooleanIterator(boolean array[], int index)
    {
        this(new BooleanArray(array), index);
    }

    BooleanIterator(BooleanArray array, int index)
    {
        super(array, index);
        offset = -1;
    }

    public BooleanIterator(BooleanBuffer vector, int index)
    {
        super(vector, index / 8);
        offset = (byte)(index % 8);
    }

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

    public boolean equals(Object object)
    {
        return (object instanceof BooleanIterator) && equals((BooleanIterator)object);
    }

    public boolean equals(BooleanIterator iterator)
    {
        return getInternalIndex() == iterator.getInternalIndex() && offset == iterator.offset && isCompatibleWith(iterator);
    }

    public int hashCode()
    {
        return System.identityHashCode(getContainer()) ^ getInternalIndex();
    }

    public boolean less(RandomAccessIterator iterator)
    {
        int index = getInternalIndex();
        if(offset == -1 && index == ((BooleanIterator)iterator).getInternalIndex())
            return offset < ((BooleanIterator)iterator).offset;
        else
            return index < ((BooleanIterator)iterator).getInternalIndex();
    }

    public boolean atBegin()
    {
        return getInternalIndex() == 0 && (offset == -1 || offset == 0);
    }

    public boolean atEnd()
    {
        return offset != -1 ? equals(getContainer().finish()) : getInternalIndex() == getContainer().size();
    }

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

    public void advance()
    {
        if(offset == -1)
            incrementIndex();
        else
        if(++offset == 8)
        {
            offset = 0;
            incrementIndex();
        }
    }

    public void advance(int n)
    {
        if(offset == -1)
        {
            incrementIndex(n);
        } else
        {
            int old = offset;
            offset = (byte)(n % 8);
            incrementIndex(n / 8);
            if(old > offset)
                incrementIndex();
        }
    }

    public void retreat()
    {
        if(offset == -1)
            decrementIndex();
        else
        if(offset == 0)
        {
            offset = 7;
            decrementIndex();
        } else
        {
            offset--;
        }
    }

    public void retreat(int n)
    {
        if(offset == -1)
        {
            decrementIndex(n);
        } else
        {
            int old = offset;
            offset = (byte)(((offset + 8) - n % 8) % 8);
            incrementIndex(n / 8);
            if(old < offset)
                incrementIndex();
        }
    }

    public boolean getBoolean()
    {
        return getBoolean(0);
    }

    public Object get(int offset)
    {
        return new Boolean(getBoolean(offset));
    }

    public boolean getBoolean(int offset)
    {
        Container container = getContainer();
        int index = getInternalIndex();
        return (container instanceof BooleanArray) ? ((BooleanArray)container).booleanAt(index + offset) : (((BooleanBuffer)container).storage.byteAt(index) & mask()) > 0;
    }

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

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

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

    public void put(int offset, boolean object)
    {
        Container container = getContainer();
        int index = getInternalIndex();
        if(container instanceof BooleanArray)
        {
            ((BooleanArray)container).put(offset, object);
        } else
        {
            ByteBuffer storage = ((BooleanBuffer)container).storage;
            byte b = storage.byteAt(index);
            if(object)
                b |= mask();
            else
                b &= ~mask();
            storage.put(index, b);
        }
    }

    public int index()
    {
        return offset != -1 ? super.getInternalIndex() * 8 + offset : super.getInternalIndex();
    }

    public boolean isCompatibleWith(InputIterator iterator)
    {
        boolean isCompatible = false;
        if(iterator instanceof BooleanIterator)
        {
            Container thisContainer = getContainer();
            BooleanIterator i = (BooleanIterator)iterator;
            Container iterContainer = i.getContainer();
            if(thisContainer instanceof BooleanArray)
                isCompatible = (iterContainer instanceof BooleanArray) && ((BooleanArray)thisContainer).array == ((BooleanArray)iterContainer).array;
            else
                isCompatible = (thisContainer instanceof BooleanBuffer) && (iterContainer instanceof BooleanBuffer) && ((BooleanBuffer)thisContainer).storage == ((BooleanBuffer)iterContainer).storage;
        }
        return isCompatible;
    }

    final byte mask()
    {
        return (byte)(1 << offset);
    }

    byte offset;
    static final long serialVersionUID = 0x7e3134af53d9ea79L;
}