| /* |
| * 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(); |
| } |