// This Source Code is in the Public Domain per: http://litesoft.org/License.txt
package org.litesoft.core.util;

import java.util.*;

import org.litesoft.core.typeutils.*;

public class SizedIterator<T> extends AbstractReadOnlyIterator<T> implements Disposable
{
    private final Long mSize;
    private Iterator<T> mIterator; // Note this is neither Volatile nor properly syncronized.  If properly used, an old reference should not harm anything!

    public SizedIterator( long pSize )
    {
        mSize = Longs.assertNonNegative( "Size", pSize );
        mIterator = NullIterator.getInstance();
    }

    public SizedIterator( Iterator<T> pIterator )
    {
        mSize = null;
        if ( pIterator != null )
        {
            mIterator = pIterator;
        }
        else
        {
            mIterator = NullIterator.getInstance();
        }
    }

    /**
     * @return May be Null...
     */
    public Long size()
    {
        return mSize;
    }

    @Override
    public boolean hasNext()
    {
        return mIterator.hasNext();
    }

    @Override
    public T next()
    {
        return mIterator.next();
    }

    private synchronized Iterator<T> replace( Iterator<T> pIterator )
    {
        Iterator<T> rv = mIterator;
        mIterator = pIterator;
        return rv;
    }

    @Override
    public void dispose()
    {
        Iterator<T> zIterator = NullIterator.getInstance();
        zIterator = replace( zIterator );
        if ( zIterator instanceof Disposable )
        {
            ((Disposable) zIterator).dispose();
        }
    }

    @Override
    protected void finalize()
            throws Throwable
    {
        dispose();
        super.finalize();
    }
}