Back to index...

	/*
	* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package java.util.stream;

	/**
	* Base class for a data structure for gathering elements into a buffer and then
	* iterating them. Maintains an array of increasingly sized arrays, so there is
	* no copying cost associated with growing the data structure.
	* @since 1.8
	*/
	abstract class AbstractSpinedBuffer {
	/**
	* Minimum power-of-two for the first chunk.
	*/
	public static final int MIN_CHUNK_POWER = 4;

	/**
	* Minimum size for the first chunk.
	*/
	public static final int MIN_CHUNK_SIZE = 1 << MIN_CHUNK_POWER;

	/**
	* Max power-of-two for chunks.
	*/
	public static final int MAX_CHUNK_POWER = 30;

	/**
	* Minimum array size for array-of-chunks.
	*/
	public static final int MIN_SPINE_SIZE = 8;


	/**
	* log2 of the size of the first chunk.
	*/
	protected final int initialChunkPower;

	/**
	* Index of the next element to write; may point into, or just outside of,
	* the current chunk.
	*/
	protected int elementIndex;

	/**
	* Index of the current chunk in the spine array, if the spine array is
	* non-null.
	*/
	protected int spineIndex;

	/**
	* Count of elements in all prior chunks.
	*/
	protected long[] priorElementCount;

	/**
	* Construct with an initial capacity of 16.
	*/
	protected AbstractSpinedBuffer() {
	this.initialChunkPower = MIN_CHUNK_POWER;
	}

	/**
	* Construct with a specified initial capacity.
	*
	* @param initialCapacity The minimum expected number of elements
	*/
	protected AbstractSpinedBuffer(int initialCapacity) {
	if (initialCapacity < 0)
	throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);

	this.initialChunkPower = Math.max(MIN_CHUNK_POWER,
	Integer.SIZE - Integer.numberOfLeadingZeros(initialCapacity - 1));
	}

	/**
	* Is the buffer currently empty?
	*/
	public boolean isEmpty() {
	return (spineIndex == 0) && (elementIndex == 0);
	}

	/**
	* How many elements are currently in the buffer?
	*/
	public long count() {
	return (spineIndex == 0)
	? elementIndex
	: priorElementCount[spineIndex] + elementIndex;
	}

	/**
	* How big should the nth chunk be?
	*/
	protected int chunkSize(int n) {
	int power = (n == 0 \|\| n == 1)
	? initialChunkPower
	: Math.min(initialChunkPower + n - 1, AbstractSpinedBuffer.MAX_CHUNK_POWER);
	return 1 << power;
	}

	/**
	* Remove all data from the buffer
	*/
	public abstract void clear();
	}

Back to index...