jdk-sandbox: comparison jdk/src/share/classes/java/util/stream/SpinedBuffer.java

equal deleted inserted replaced

-:e845f3a78db5
+:2725a30c1a02
 /**
 * Return a {@link Spliterator} describing the contents of the buffer.
 */
 public Spliterator<E> spliterator() {
-return new Spliterator<E>() {
+class Splitr implements Spliterator<E> {
 // The current spine index
 int splSpineIndex;
+// Last spine index
+final int lastSpineIndex;
 // The current element index into the current spine
 int splElementIndex;
-// When splSpineIndex >= spineIndex and splElementIndex >= elementIndex then
+// Last spine's last element index + 1
+final int lastSpineElementFence;
+// When splSpineIndex >= lastSpineIndex and
+// splElementIndex >= lastSpineElementFence then
 // this spliterator is fully traversed
 // tryAdvance can set splSpineIndex > spineIndex if the last spine is full
 // The current spine array
-E[] splChunk = (spine == null) ? curChunk : spine[0];
+E[] splChunk;
+Splitr(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+this.splSpineIndex = firstSpineIndex;
+this.lastSpineIndex = lastSpineIndex;
+this.splElementIndex = firstSpineElementIndex;
+this.lastSpineElementFence = lastSpineElementFence;
+assert spine != null || firstSpineIndex == 0 && lastSpineIndex == 0;
+splChunk = (spine == null) ? curChunk : spine[firstSpineIndex];
+}
 @Override
 public long estimateSize() {
-return (spine == null)
+return (splSpineIndex == lastSpineIndex)
-? (elementIndex - splElementIndex)
+? (long) lastSpineElementFence - splElementIndex
-: count() - (priorElementCount[splSpineIndex] + splElementIndex);
+: // # of elements prior to end -
+priorElementCount[lastSpineIndex] + lastSpineElementFence -
+// # of elements prior to current
+priorElementCount[splSpineIndex] - splElementIndex;
 }
 @Override
 public int characteristics() {
 return SPLITERATOR_CHARACTERISTICS;
 }
 @Override
 public boolean tryAdvance(Consumer<? super E> consumer) {
-if (splSpineIndex < spineIndex
+if (splSpineIndex < lastSpineIndex
-|| (splSpineIndex == spineIndex && splElementIndex < elementIndex)) {
+|| (splSpineIndex == lastSpineIndex && splElementIndex < lastSpineElementFence)) {
 consumer.accept(splChunk[splElementIndex++]);
 if (splElementIndex == splChunk.length) {
 splElementIndex = 0;
 ++splSpineIndex;
-if (spine != null && splSpineIndex < spine.length)
+if (spine != null && splSpineIndex <= lastSpineIndex)
 splChunk = spine[splSpineIndex];
 }
 return true;
 }
 return false;
 }
 @Override
 public void forEachRemaining(Consumer<? super E> consumer) {
-if (splSpineIndex < spineIndex
+if (splSpineIndex < lastSpineIndex
-|| (splSpineIndex == spineIndex && splElementIndex < elementIndex)) {
+|| (splSpineIndex == lastSpineIndex && splElementIndex < lastSpineElementFence)) {
 int i = splElementIndex;
 // completed chunks, if any
-for (int sp = splSpineIndex; sp < spineIndex; sp++) {
+for (int sp = splSpineIndex; sp < lastSpineIndex; sp++) {
 E[] chunk = spine[sp];
 for (; i < chunk.length; i++) {
 consumer.accept(chunk[i]);
 }
 i = 0;
 }
+// last (or current uncompleted) chunk
-// current chunk
+E[] chunk = (splSpineIndex == lastSpineIndex) ? splChunk : spine[lastSpineIndex];
-E[] chunk = curChunk;
+int hElementIndex = lastSpineElementFence;
-int hElementIndex = elementIndex;
 for (; i < hElementIndex; i++) {
 consumer.accept(chunk[i]);
 }
+// mark consumed
-splSpineIndex = spineIndex;
+splSpineIndex = lastSpineIndex;
-splElementIndex = elementIndex;
+splElementIndex = lastSpineElementFence;
 }
 }
 @Override
 public Spliterator<E> trySplit() {
-if (splSpineIndex < spineIndex) {
+if (splSpineIndex < lastSpineIndex) {
-Spliterator<E> ret = Arrays.spliterator(spine[splSpineIndex],
+// split just before last chunk (if it is full this means 50:50 split)
-splElementIndex, spine[splSpineIndex].length);
+Spliterator<E> ret = new Splitr(splSpineIndex, lastSpineIndex - 1,
-splChunk = spine[++splSpineIndex];
+splElementIndex, spine[lastSpineIndex-1].length);
+// position to start of last chunk
+splSpineIndex = lastSpineIndex;
 splElementIndex = 0;
+splChunk = spine[splSpineIndex];
 return ret;
 }
-else if (splSpineIndex == spineIndex) {
+else if (splSpineIndex == lastSpineIndex) {
-int t = (elementIndex - splElementIndex) / 2;
+int t = (lastSpineElementFence - splElementIndex) / 2;
 if (t == 0)
 return null;
 else {
-Spliterator<E> ret = Arrays.spliterator(curChunk, splElementIndex, splElementIndex + t);
+Spliterator<E> ret = Arrays.spliterator(splChunk, splElementIndex, splElementIndex + t);
 splElementIndex += t;
 return ret;
 }
 }
 else {
 return null;
 }
 }
-};
+}
+return new Splitr(0, spineIndex, 0, elementIndex);
 }
 /**
 * An ordered collection of primitive values.  Elements can be added, but
 * not removed. Goes through a building phase, during which elements can be
 /** Create a new array-of-array of the proper type and size */
 protected abstract T_ARR[] newArrayArray(int size);
 /** Create a new array of the proper type and size */
-protected abstract T_ARR newArray(int size);
+public abstract T_ARR newArray(int size);
 /** Get the length of an array */
 protected abstract int arrayLength(T_ARR array);
 /** Iterate an array with the provided consumer */
 // current chunk
 arrayForEach(curChunk, 0, elementIndex, consumer);
 }
-abstract class BaseSpliterator<T_SPLITER extends Spliterator<E>>
+abstract class BaseSpliterator<T_SPLITR extends Spliterator.OfPrimitive<E, T_CONS, T_SPLITR>>
-implements Spliterator<E> {
+implements Spliterator.OfPrimitive<E, T_CONS, T_SPLITR> {
 // The current spine index
 int splSpineIndex;
+// Last spine index
+final int lastSpineIndex;
 // The current element index into the current spine
 int splElementIndex;
-// When splSpineIndex >= spineIndex and splElementIndex >= elementIndex then
+// Last spine's last element index + 1
+final int lastSpineElementFence;
+// When splSpineIndex >= lastSpineIndex and
+// splElementIndex >= lastSpineElementFence then
 // this spliterator is fully traversed
 // tryAdvance can set splSpineIndex > spineIndex if the last spine is full
 // The current spine array
-T_ARR splChunk = (spine == null) ? curChunk : spine[0];
+T_ARR splChunk;
+BaseSpliterator(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+this.splSpineIndex = firstSpineIndex;
+this.lastSpineIndex = lastSpineIndex;
+this.splElementIndex = firstSpineElementIndex;
+this.lastSpineElementFence = lastSpineElementFence;
+assert spine != null || firstSpineIndex == 0 && lastSpineIndex == 0;
+splChunk = (spine == null) ? curChunk : spine[firstSpineIndex];
+}
+abstract T_SPLITR newSpliterator(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence);
 abstract void arrayForOne(T_ARR array, int index, T_CONS consumer);
-abstract T_SPLITER arraySpliterator(T_ARR array, int offset, int len);
+abstract T_SPLITR arraySpliterator(T_ARR array, int offset, int len);
 @Override
 public long estimateSize() {
-return (spine == null)
+return (splSpineIndex == lastSpineIndex)
-? (elementIndex - splElementIndex)
+? (long) lastSpineElementFence - splElementIndex
-: count() - (priorElementCount[splSpineIndex] + splElementIndex);
+: // # of elements prior to end -
+priorElementCount[lastSpineIndex] + lastSpineElementFence -
+// # of elements prior to current
+priorElementCount[splSpineIndex] - splElementIndex;
 }
 @Override
 public int characteristics() {
 return SPLITERATOR_CHARACTERISTICS;
 }
+@Override
 public boolean tryAdvance(T_CONS consumer) {
-if (splSpineIndex < spineIndex
+if (splSpineIndex < lastSpineIndex
-|| (splSpineIndex == spineIndex && splElementIndex < elementIndex)) {
+|| (splSpineIndex == lastSpineIndex && splElementIndex < lastSpineElementFence)) {
 arrayForOne(splChunk, splElementIndex++, consumer);
 if (splElementIndex == arrayLength(splChunk)) {
 splElementIndex = 0;
 ++splSpineIndex;
-if (spine != null && splSpineIndex < spine.length)
+if (spine != null && splSpineIndex <= lastSpineIndex)
 splChunk = spine[splSpineIndex];
 }
 return true;
 }
 return false;
 }
+@Override
 public void forEachRemaining(T_CONS consumer) {
-if (splSpineIndex < spineIndex
+if (splSpineIndex < lastSpineIndex
-|| (splSpineIndex == spineIndex && splElementIndex < elementIndex)) {
+|| (splSpineIndex == lastSpineIndex && splElementIndex < lastSpineElementFence)) {
 int i = splElementIndex;
 // completed chunks, if any
-for (int sp = splSpineIndex; sp < spineIndex; sp++) {
+for (int sp = splSpineIndex; sp < lastSpineIndex; sp++) {
 T_ARR chunk = spine[sp];
 arrayForEach(chunk, i, arrayLength(chunk), consumer);
 i = 0;
 }
+// last (or current uncompleted) chunk
-arrayForEach(curChunk, i, elementIndex, consumer);
+T_ARR chunk = (splSpineIndex == lastSpineIndex) ? splChunk : spine[lastSpineIndex];
+arrayForEach(chunk, i, lastSpineElementFence, consumer);
-splSpineIndex = spineIndex;
+// mark consumed
-splElementIndex = elementIndex;
+splSpineIndex = lastSpineIndex;
+splElementIndex = lastSpineElementFence;
 }
 }
 @Override
-public T_SPLITER trySplit() {
+public T_SPLITR trySplit() {
-if (splSpineIndex < spineIndex) {
+if (splSpineIndex < lastSpineIndex) {
-T_SPLITER ret = arraySpliterator(spine[splSpineIndex], splElementIndex,
+// split just before last chunk (if it is full this means 50:50 split)
-arrayLength(spine[splSpineIndex]) - splElementIndex);
+T_SPLITR ret = newSpliterator(splSpineIndex, lastSpineIndex - 1,
-splChunk = spine[++splSpineIndex];
+splElementIndex, arrayLength(spine[lastSpineIndex - 1]));
+// position us to start of last chunk
+splSpineIndex = lastSpineIndex;
 splElementIndex = 0;
+splChunk = spine[splSpineIndex];
 return ret;
 }
-else if (splSpineIndex == spineIndex) {
+else if (splSpineIndex == lastSpineIndex) {
-int t = (elementIndex - splElementIndex) / 2;
+int t = (lastSpineElementFence - splElementIndex) / 2;
 if (t == 0)
 return null;
 else {
-T_SPLITER ret = arraySpliterator(curChunk, splElementIndex, t);
+T_SPLITR ret = arraySpliterator(splChunk, splElementIndex, t);
 splElementIndex += t;
 return ret;
 }
 }
 else {
 protected int[][] newArrayArray(int size) {
 return new int[size][];
 }
 @Override
-protected int[] newArray(int size) {
+public int[] newArray(int size) {
 return new int[size];
 }
 @Override
 protected int arrayLength(int[] array) {
 return curChunk[(int) index];
 else
 return spine[ch][(int) (index-priorElementCount[ch])];
 }
-public int[] asIntArray() {
-return asPrimitiveArray();
-}
 @Override
 public PrimitiveIterator.OfInt iterator() {
 return Spliterators.iterator(spliterator());
 }
 public Spliterator.OfInt spliterator() {
 class Splitr extends BaseSpliterator<Spliterator.OfInt>
 implements Spliterator.OfInt {
+Splitr(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+super(firstSpineIndex, lastSpineIndex,
+firstSpineElementIndex, lastSpineElementFence);
+}
+@Override
+Splitr newSpliterator(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+return new Splitr(firstSpineIndex, lastSpineIndex,
+firstSpineElementIndex, lastSpineElementFence);
+}
 @Override
 void arrayForOne(int[] array, int index, IntConsumer consumer) {
 consumer.accept(array[index]);
 }
 @Override
 Spliterator.OfInt arraySpliterator(int[] array, int offset, int len) {
 return Arrays.spliterator(array, offset, offset+len);
 }
-};
+}
-return new Splitr();
+return new Splitr(0, spineIndex, 0, elementIndex);
 }
 @Override
 public String toString() {
-int[] array = asIntArray();
+int[] array = asPrimitiveArray();
 if (array.length < 200) {
 return String.format("%s[length=%d, chunks=%d]%s",
 getClass().getSimpleName(), array.length,
 spineIndex, Arrays.toString(array));
 }
 protected long[][] newArrayArray(int size) {
 return new long[size][];
 }
 @Override
-protected long[] newArray(int size) {
+public long[] newArray(int size) {
 return new long[size];
 }
 @Override
 protected int arrayLength(long[] array) {
 return curChunk[(int) index];
 else
 return spine[ch][(int) (index-priorElementCount[ch])];
 }
-public long[] asLongArray() {
-return asPrimitiveArray();
-}
 @Override
 public PrimitiveIterator.OfLong iterator() {
 return Spliterators.iterator(spliterator());
 }
 public Spliterator.OfLong spliterator() {
 class Splitr extends BaseSpliterator<Spliterator.OfLong>
 implements Spliterator.OfLong {
+Splitr(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+super(firstSpineIndex, lastSpineIndex,
+firstSpineElementIndex, lastSpineElementFence);
+}
+@Override
+Splitr newSpliterator(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+return new Splitr(firstSpineIndex, lastSpineIndex,
+firstSpineElementIndex, lastSpineElementFence);
+}
 @Override
 void arrayForOne(long[] array, int index, LongConsumer consumer) {
 consumer.accept(array[index]);
 }
 @Override
 Spliterator.OfLong arraySpliterator(long[] array, int offset, int len) {
 return Arrays.spliterator(array, offset, offset+len);
 }
-};
+}
-return new Splitr();
+return new Splitr(0, spineIndex, 0, elementIndex);
 }
 @Override
 public String toString() {
-long[] array = asLongArray();
+long[] array = asPrimitiveArray();
 if (array.length < 200) {
 return String.format("%s[length=%d, chunks=%d]%s",
 getClass().getSimpleName(), array.length,
 spineIndex, Arrays.toString(array));
 }
 protected double[][] newArrayArray(int size) {
 return new double[size][];
 }
 @Override
-protected double[] newArray(int size) {
+public double[] newArray(int size) {
 return new double[size];
 }
 @Override
 protected int arrayLength(double[] array) {
 return curChunk[(int) index];
 else
 return spine[ch][(int) (index-priorElementCount[ch])];
 }
-public double[] asDoubleArray() {
-return asPrimitiveArray();
-}
 @Override
 public PrimitiveIterator.OfDouble iterator() {
 return Spliterators.iterator(spliterator());
 }
 public Spliterator.OfDouble spliterator() {
 class Splitr extends BaseSpliterator<Spliterator.OfDouble>
 implements Spliterator.OfDouble {
+Splitr(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+super(firstSpineIndex, lastSpineIndex,
+firstSpineElementIndex, lastSpineElementFence);
+}
+@Override
+Splitr newSpliterator(int firstSpineIndex, int lastSpineIndex,
+int firstSpineElementIndex, int lastSpineElementFence) {
+return new Splitr(firstSpineIndex, lastSpineIndex,
+firstSpineElementIndex, lastSpineElementFence);
+}
 @Override
 void arrayForOne(double[] array, int index, DoubleConsumer consumer) {
 consumer.accept(array[index]);
 }
 @Override
 Spliterator.OfDouble arraySpliterator(double[] array, int offset, int len) {
 return Arrays.spliterator(array, offset, offset+len);
 }
 }
-return new Splitr();
+return new Splitr(0, spineIndex, 0, elementIndex);
 }
 @Override
 public String toString() {
-double[] array = asDoubleArray();
+double[] array = asPrimitiveArray();
 if (array.length < 200) {
 return String.format("%s[length=%d, chunks=%d]%s",
 getClass().getSimpleName(), array.length,
 spineIndex, Arrays.toString(array));
 }

changeset 18171	2725a30c1a02
parent 18155	889970e5b728
child 19188	bbf287c5cd92