2236 lines
78 KiB
Java
2236 lines
78 KiB
Java
/*
|
|
* Copyright (c) 2012, 2015, 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;
|
|
|
|
import java.util.ArrayDeque;
|
|
import java.util.Arrays;
|
|
import java.util.Collection;
|
|
import java.util.Deque;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.Spliterator;
|
|
import java.util.Spliterators;
|
|
import java.util.concurrent.CountedCompleter;
|
|
import java.util.function.BinaryOperator;
|
|
import java.util.function.Consumer;
|
|
import java.util.function.DoubleConsumer;
|
|
import java.util.function.IntConsumer;
|
|
import java.util.function.IntFunction;
|
|
import java.util.function.LongConsumer;
|
|
import java.util.function.LongFunction;
|
|
|
|
/**
|
|
* Factory methods for constructing implementations of {@link Node} and
|
|
* {@link Node.Builder} and their primitive specializations. Fork/Join tasks
|
|
* for collecting output from a {@link PipelineHelper} to a {@link Node} and
|
|
* flattening {@link Node}s.
|
|
*
|
|
* @since 1.8
|
|
*/
|
|
final class Nodes {
|
|
|
|
private Nodes() {
|
|
throw new Error("no instances");
|
|
}
|
|
|
|
/**
|
|
* The maximum size of an array that can be allocated.
|
|
*/
|
|
static final long MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
|
|
|
|
// IllegalArgumentException messages
|
|
static final String BAD_SIZE = "Stream size exceeds max array size";
|
|
|
|
@SuppressWarnings("rawtypes")
|
|
private static final Node EMPTY_NODE = new EmptyNode.OfRef();
|
|
private static final Node.OfInt EMPTY_INT_NODE = new EmptyNode.OfInt();
|
|
private static final Node.OfLong EMPTY_LONG_NODE = new EmptyNode.OfLong();
|
|
private static final Node.OfDouble EMPTY_DOUBLE_NODE = new EmptyNode.OfDouble();
|
|
|
|
/**
|
|
* @return an array generator for an array whose elements are of type T.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
static <T> IntFunction<T[]> castingArray() {
|
|
return size -> (T[]) new Object[size];
|
|
}
|
|
|
|
// General shape-based node creation methods
|
|
|
|
/**
|
|
* Produces an empty node whose count is zero, has no children and no content.
|
|
*
|
|
* @param <T> the type of elements of the created node
|
|
* @param shape the shape of the node to be created
|
|
* @return an empty node.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
static <T> Node<T> emptyNode(StreamShape shape) {
|
|
switch (shape) {
|
|
case REFERENCE: return (Node<T>) EMPTY_NODE;
|
|
case INT_VALUE: return (Node<T>) EMPTY_INT_NODE;
|
|
case LONG_VALUE: return (Node<T>) EMPTY_LONG_NODE;
|
|
case DOUBLE_VALUE: return (Node<T>) EMPTY_DOUBLE_NODE;
|
|
default:
|
|
throw new IllegalStateException("Unknown shape " + shape);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Produces a concatenated {@link Node} that has two or more children.
|
|
* <p>The count of the concatenated node is equal to the sum of the count
|
|
* of each child. Traversal of the concatenated node traverses the content
|
|
* of each child in encounter order of the list of children. Splitting a
|
|
* spliterator obtained from the concatenated node preserves the encounter
|
|
* order of the list of children.
|
|
*
|
|
* <p>The result may be a concatenated node, the input sole node if the size
|
|
* of the list is 1, or an empty node.
|
|
*
|
|
* @param <T> the type of elements of the concatenated node
|
|
* @param shape the shape of the concatenated node to be created
|
|
* @param left the left input node
|
|
* @param right the right input node
|
|
* @return a {@code Node} covering the elements of the input nodes
|
|
* @throws IllegalStateException if all {@link Node} elements of the list
|
|
* are an not instance of type supported by this factory.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
static <T> Node<T> conc(StreamShape shape, Node<T> left, Node<T> right) {
|
|
switch (shape) {
|
|
case REFERENCE:
|
|
return new ConcNode<>(left, right);
|
|
case INT_VALUE:
|
|
return (Node<T>) new ConcNode.OfInt((Node.OfInt) left, (Node.OfInt) right);
|
|
case LONG_VALUE:
|
|
return (Node<T>) new ConcNode.OfLong((Node.OfLong) left, (Node.OfLong) right);
|
|
case DOUBLE_VALUE:
|
|
return (Node<T>) new ConcNode.OfDouble((Node.OfDouble) left, (Node.OfDouble) right);
|
|
default:
|
|
throw new IllegalStateException("Unknown shape " + shape);
|
|
}
|
|
}
|
|
|
|
// Reference-based node methods
|
|
|
|
/**
|
|
* Produces a {@link Node} describing an array.
|
|
*
|
|
* <p>The node will hold a reference to the array and will not make a copy.
|
|
*
|
|
* @param <T> the type of elements held by the node
|
|
* @param array the array
|
|
* @return a node holding an array
|
|
*/
|
|
static <T> Node<T> node(T[] array) {
|
|
return new ArrayNode<>(array);
|
|
}
|
|
|
|
/**
|
|
* Produces a {@link Node} describing a {@link Collection}.
|
|
* <p>
|
|
* The node will hold a reference to the collection and will not make a copy.
|
|
*
|
|
* @param <T> the type of elements held by the node
|
|
* @param c the collection
|
|
* @return a node holding a collection
|
|
*/
|
|
static <T> Node<T> node(Collection<T> c) {
|
|
return new CollectionNode<>(c);
|
|
}
|
|
|
|
/**
|
|
* Produces a {@link Node.Builder}.
|
|
*
|
|
* @param exactSizeIfKnown -1 if a variable size builder is requested,
|
|
* otherwise the exact capacity desired. A fixed capacity builder will
|
|
* fail if the wrong number of elements are added to the builder.
|
|
* @param generator the array factory
|
|
* @param <T> the type of elements of the node builder
|
|
* @return a {@code Node.Builder}
|
|
*/
|
|
static <T> Node.Builder<T> builder(long exactSizeIfKnown, IntFunction<T[]> generator) {
|
|
return (exactSizeIfKnown >= 0 && exactSizeIfKnown < MAX_ARRAY_SIZE)
|
|
? new FixedNodeBuilder<>(exactSizeIfKnown, generator)
|
|
: builder();
|
|
}
|
|
|
|
/**
|
|
* Produces a variable size @{link Node.Builder}.
|
|
*
|
|
* @param <T> the type of elements of the node builder
|
|
* @return a {@code Node.Builder}
|
|
*/
|
|
static <T> Node.Builder<T> builder() {
|
|
return new SpinedNodeBuilder<>();
|
|
}
|
|
|
|
// Int nodes
|
|
|
|
/**
|
|
* Produces a {@link Node.OfInt} describing an int[] array.
|
|
*
|
|
* <p>The node will hold a reference to the array and will not make a copy.
|
|
*
|
|
* @param array the array
|
|
* @return a node holding an array
|
|
*/
|
|
static Node.OfInt node(int[] array) {
|
|
return new IntArrayNode(array);
|
|
}
|
|
|
|
/**
|
|
* Produces a {@link Node.Builder.OfInt}.
|
|
*
|
|
* @param exactSizeIfKnown -1 if a variable size builder is requested,
|
|
* otherwise the exact capacity desired. A fixed capacity builder will
|
|
* fail if the wrong number of elements are added to the builder.
|
|
* @return a {@code Node.Builder.OfInt}
|
|
*/
|
|
static Node.Builder.OfInt intBuilder(long exactSizeIfKnown) {
|
|
return (exactSizeIfKnown >= 0 && exactSizeIfKnown < MAX_ARRAY_SIZE)
|
|
? new IntFixedNodeBuilder(exactSizeIfKnown)
|
|
: intBuilder();
|
|
}
|
|
|
|
/**
|
|
* Produces a variable size @{link Node.Builder.OfInt}.
|
|
*
|
|
* @return a {@code Node.Builder.OfInt}
|
|
*/
|
|
static Node.Builder.OfInt intBuilder() {
|
|
return new IntSpinedNodeBuilder();
|
|
}
|
|
|
|
// Long nodes
|
|
|
|
/**
|
|
* Produces a {@link Node.OfLong} describing a long[] array.
|
|
* <p>
|
|
* The node will hold a reference to the array and will not make a copy.
|
|
*
|
|
* @param array the array
|
|
* @return a node holding an array
|
|
*/
|
|
static Node.OfLong node(final long[] array) {
|
|
return new LongArrayNode(array);
|
|
}
|
|
|
|
/**
|
|
* Produces a {@link Node.Builder.OfLong}.
|
|
*
|
|
* @param exactSizeIfKnown -1 if a variable size builder is requested,
|
|
* otherwise the exact capacity desired. A fixed capacity builder will
|
|
* fail if the wrong number of elements are added to the builder.
|
|
* @return a {@code Node.Builder.OfLong}
|
|
*/
|
|
static Node.Builder.OfLong longBuilder(long exactSizeIfKnown) {
|
|
return (exactSizeIfKnown >= 0 && exactSizeIfKnown < MAX_ARRAY_SIZE)
|
|
? new LongFixedNodeBuilder(exactSizeIfKnown)
|
|
: longBuilder();
|
|
}
|
|
|
|
/**
|
|
* Produces a variable size @{link Node.Builder.OfLong}.
|
|
*
|
|
* @return a {@code Node.Builder.OfLong}
|
|
*/
|
|
static Node.Builder.OfLong longBuilder() {
|
|
return new LongSpinedNodeBuilder();
|
|
}
|
|
|
|
// Double nodes
|
|
|
|
/**
|
|
* Produces a {@link Node.OfDouble} describing a double[] array.
|
|
*
|
|
* <p>The node will hold a reference to the array and will not make a copy.
|
|
*
|
|
* @param array the array
|
|
* @return a node holding an array
|
|
*/
|
|
static Node.OfDouble node(final double[] array) {
|
|
return new DoubleArrayNode(array);
|
|
}
|
|
|
|
/**
|
|
* Produces a {@link Node.Builder.OfDouble}.
|
|
*
|
|
* @param exactSizeIfKnown -1 if a variable size builder is requested,
|
|
* otherwise the exact capacity desired. A fixed capacity builder will
|
|
* fail if the wrong number of elements are added to the builder.
|
|
* @return a {@code Node.Builder.OfDouble}
|
|
*/
|
|
static Node.Builder.OfDouble doubleBuilder(long exactSizeIfKnown) {
|
|
return (exactSizeIfKnown >= 0 && exactSizeIfKnown < MAX_ARRAY_SIZE)
|
|
? new DoubleFixedNodeBuilder(exactSizeIfKnown)
|
|
: doubleBuilder();
|
|
}
|
|
|
|
/**
|
|
* Produces a variable size @{link Node.Builder.OfDouble}.
|
|
*
|
|
* @return a {@code Node.Builder.OfDouble}
|
|
*/
|
|
static Node.Builder.OfDouble doubleBuilder() {
|
|
return new DoubleSpinedNodeBuilder();
|
|
}
|
|
|
|
// Parallel evaluation of pipelines to nodes
|
|
|
|
/**
|
|
* Collect, in parallel, elements output from a pipeline and describe those
|
|
* elements with a {@link Node}.
|
|
*
|
|
* @implSpec
|
|
* If the exact size of the output from the pipeline is known and the source
|
|
* {@link Spliterator} has the {@link Spliterator#SUBSIZED} characteristic,
|
|
* then a flat {@link Node} will be returned whose content is an array,
|
|
* since the size is known the array can be constructed in advance and
|
|
* output elements can be placed into the array concurrently by leaf
|
|
* tasks at the correct offsets. If the exact size is not known, output
|
|
* elements are collected into a conc-node whose shape mirrors that
|
|
* of the computation. This conc-node can then be flattened in
|
|
* parallel to produce a flat {@code Node} if desired.
|
|
*
|
|
* @param helper the pipeline helper describing the pipeline
|
|
* @param flattenTree whether a conc node should be flattened into a node
|
|
* describing an array before returning
|
|
* @param generator the array generator
|
|
* @return a {@link Node} describing the output elements
|
|
*/
|
|
public static <P_IN, P_OUT> Node<P_OUT> collect(PipelineHelper<P_OUT> helper,
|
|
Spliterator<P_IN> spliterator,
|
|
boolean flattenTree,
|
|
IntFunction<P_OUT[]> generator) {
|
|
long size = helper.exactOutputSizeIfKnown(spliterator);
|
|
if (size >= 0 && spliterator.hasCharacteristics(Spliterator.SUBSIZED)) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
P_OUT[] array = generator.apply((int) size);
|
|
new SizedCollectorTask.OfRef<>(spliterator, helper, array).invoke();
|
|
return node(array);
|
|
} else {
|
|
Node<P_OUT> node = new CollectorTask.OfRef<>(helper, generator, spliterator).invoke();
|
|
return flattenTree ? flatten(node, generator) : node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Collect, in parallel, elements output from an int-valued pipeline and
|
|
* describe those elements with a {@link Node.OfInt}.
|
|
*
|
|
* @implSpec
|
|
* If the exact size of the output from the pipeline is known and the source
|
|
* {@link Spliterator} has the {@link Spliterator#SUBSIZED} characteristic,
|
|
* then a flat {@link Node} will be returned whose content is an array,
|
|
* since the size is known the array can be constructed in advance and
|
|
* output elements can be placed into the array concurrently by leaf
|
|
* tasks at the correct offsets. If the exact size is not known, output
|
|
* elements are collected into a conc-node whose shape mirrors that
|
|
* of the computation. This conc-node can then be flattened in
|
|
* parallel to produce a flat {@code Node.OfInt} if desired.
|
|
*
|
|
* @param <P_IN> the type of elements from the source Spliterator
|
|
* @param helper the pipeline helper describing the pipeline
|
|
* @param flattenTree whether a conc node should be flattened into a node
|
|
* describing an array before returning
|
|
* @return a {@link Node.OfInt} describing the output elements
|
|
*/
|
|
public static <P_IN> Node.OfInt collectInt(PipelineHelper<Integer> helper,
|
|
Spliterator<P_IN> spliterator,
|
|
boolean flattenTree) {
|
|
long size = helper.exactOutputSizeIfKnown(spliterator);
|
|
if (size >= 0 && spliterator.hasCharacteristics(Spliterator.SUBSIZED)) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
int[] array = new int[(int) size];
|
|
new SizedCollectorTask.OfInt<>(spliterator, helper, array).invoke();
|
|
return node(array);
|
|
}
|
|
else {
|
|
Node.OfInt node = new CollectorTask.OfInt<>(helper, spliterator).invoke();
|
|
return flattenTree ? flattenInt(node) : node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Collect, in parallel, elements output from a long-valued pipeline and
|
|
* describe those elements with a {@link Node.OfLong}.
|
|
*
|
|
* @implSpec
|
|
* If the exact size of the output from the pipeline is known and the source
|
|
* {@link Spliterator} has the {@link Spliterator#SUBSIZED} characteristic,
|
|
* then a flat {@link Node} will be returned whose content is an array,
|
|
* since the size is known the array can be constructed in advance and
|
|
* output elements can be placed into the array concurrently by leaf
|
|
* tasks at the correct offsets. If the exact size is not known, output
|
|
* elements are collected into a conc-node whose shape mirrors that
|
|
* of the computation. This conc-node can then be flattened in
|
|
* parallel to produce a flat {@code Node.OfLong} if desired.
|
|
*
|
|
* @param <P_IN> the type of elements from the source Spliterator
|
|
* @param helper the pipeline helper describing the pipeline
|
|
* @param flattenTree whether a conc node should be flattened into a node
|
|
* describing an array before returning
|
|
* @return a {@link Node.OfLong} describing the output elements
|
|
*/
|
|
public static <P_IN> Node.OfLong collectLong(PipelineHelper<Long> helper,
|
|
Spliterator<P_IN> spliterator,
|
|
boolean flattenTree) {
|
|
long size = helper.exactOutputSizeIfKnown(spliterator);
|
|
if (size >= 0 && spliterator.hasCharacteristics(Spliterator.SUBSIZED)) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
long[] array = new long[(int) size];
|
|
new SizedCollectorTask.OfLong<>(spliterator, helper, array).invoke();
|
|
return node(array);
|
|
}
|
|
else {
|
|
Node.OfLong node = new CollectorTask.OfLong<>(helper, spliterator).invoke();
|
|
return flattenTree ? flattenLong(node) : node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Collect, in parallel, elements output from n double-valued pipeline and
|
|
* describe those elements with a {@link Node.OfDouble}.
|
|
*
|
|
* @implSpec
|
|
* If the exact size of the output from the pipeline is known and the source
|
|
* {@link Spliterator} has the {@link Spliterator#SUBSIZED} characteristic,
|
|
* then a flat {@link Node} will be returned whose content is an array,
|
|
* since the size is known the array can be constructed in advance and
|
|
* output elements can be placed into the array concurrently by leaf
|
|
* tasks at the correct offsets. If the exact size is not known, output
|
|
* elements are collected into a conc-node whose shape mirrors that
|
|
* of the computation. This conc-node can then be flattened in
|
|
* parallel to produce a flat {@code Node.OfDouble} if desired.
|
|
*
|
|
* @param <P_IN> the type of elements from the source Spliterator
|
|
* @param helper the pipeline helper describing the pipeline
|
|
* @param flattenTree whether a conc node should be flattened into a node
|
|
* describing an array before returning
|
|
* @return a {@link Node.OfDouble} describing the output elements
|
|
*/
|
|
public static <P_IN> Node.OfDouble collectDouble(PipelineHelper<Double> helper,
|
|
Spliterator<P_IN> spliterator,
|
|
boolean flattenTree) {
|
|
long size = helper.exactOutputSizeIfKnown(spliterator);
|
|
if (size >= 0 && spliterator.hasCharacteristics(Spliterator.SUBSIZED)) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
double[] array = new double[(int) size];
|
|
new SizedCollectorTask.OfDouble<>(spliterator, helper, array).invoke();
|
|
return node(array);
|
|
}
|
|
else {
|
|
Node.OfDouble node = new CollectorTask.OfDouble<>(helper, spliterator).invoke();
|
|
return flattenTree ? flattenDouble(node) : node;
|
|
}
|
|
}
|
|
|
|
// Parallel flattening of nodes
|
|
|
|
/**
|
|
* Flatten, in parallel, a {@link Node}. A flattened node is one that has
|
|
* no children. If the node is already flat, it is simply returned.
|
|
*
|
|
* @implSpec
|
|
* If a new node is to be created, the generator is used to create an array
|
|
* whose length is {@link Node#count()}. Then the node tree is traversed
|
|
* and leaf node elements are placed in the array concurrently by leaf tasks
|
|
* at the correct offsets.
|
|
*
|
|
* @param <T> type of elements contained by the node
|
|
* @param node the node to flatten
|
|
* @param generator the array factory used to create array instances
|
|
* @return a flat {@code Node}
|
|
*/
|
|
public static <T> Node<T> flatten(Node<T> node, IntFunction<T[]> generator) {
|
|
if (node.getChildCount() > 0) {
|
|
long size = node.count();
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
T[] array = generator.apply((int) size);
|
|
new ToArrayTask.OfRef<>(node, array, 0).invoke();
|
|
return node(array);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flatten, in parallel, a {@link Node.OfInt}. A flattened node is one that
|
|
* has no children. If the node is already flat, it is simply returned.
|
|
*
|
|
* @implSpec
|
|
* If a new node is to be created, a new int[] array is created whose length
|
|
* is {@link Node#count()}. Then the node tree is traversed and leaf node
|
|
* elements are placed in the array concurrently by leaf tasks at the
|
|
* correct offsets.
|
|
*
|
|
* @param node the node to flatten
|
|
* @return a flat {@code Node.OfInt}
|
|
*/
|
|
public static Node.OfInt flattenInt(Node.OfInt node) {
|
|
if (node.getChildCount() > 0) {
|
|
long size = node.count();
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
int[] array = new int[(int) size];
|
|
new ToArrayTask.OfInt(node, array, 0).invoke();
|
|
return node(array);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flatten, in parallel, a {@link Node.OfLong}. A flattened node is one that
|
|
* has no children. If the node is already flat, it is simply returned.
|
|
*
|
|
* @implSpec
|
|
* If a new node is to be created, a new long[] array is created whose length
|
|
* is {@link Node#count()}. Then the node tree is traversed and leaf node
|
|
* elements are placed in the array concurrently by leaf tasks at the
|
|
* correct offsets.
|
|
*
|
|
* @param node the node to flatten
|
|
* @return a flat {@code Node.OfLong}
|
|
*/
|
|
public static Node.OfLong flattenLong(Node.OfLong node) {
|
|
if (node.getChildCount() > 0) {
|
|
long size = node.count();
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
long[] array = new long[(int) size];
|
|
new ToArrayTask.OfLong(node, array, 0).invoke();
|
|
return node(array);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flatten, in parallel, a {@link Node.OfDouble}. A flattened node is one that
|
|
* has no children. If the node is already flat, it is simply returned.
|
|
*
|
|
* @implSpec
|
|
* If a new node is to be created, a new double[] array is created whose length
|
|
* is {@link Node#count()}. Then the node tree is traversed and leaf node
|
|
* elements are placed in the array concurrently by leaf tasks at the
|
|
* correct offsets.
|
|
*
|
|
* @param node the node to flatten
|
|
* @return a flat {@code Node.OfDouble}
|
|
*/
|
|
public static Node.OfDouble flattenDouble(Node.OfDouble node) {
|
|
if (node.getChildCount() > 0) {
|
|
long size = node.count();
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
double[] array = new double[(int) size];
|
|
new ToArrayTask.OfDouble(node, array, 0).invoke();
|
|
return node(array);
|
|
} else {
|
|
return node;
|
|
}
|
|
}
|
|
|
|
// Implementations
|
|
|
|
private abstract static class EmptyNode<T, T_ARR, T_CONS> implements Node<T> {
|
|
EmptyNode() { }
|
|
|
|
@Override
|
|
public T[] asArray(IntFunction<T[]> generator) {
|
|
return generator.apply(0);
|
|
}
|
|
|
|
public void copyInto(T_ARR array, int offset) { }
|
|
|
|
@Override
|
|
public long count() {
|
|
return 0;
|
|
}
|
|
|
|
public void forEach(T_CONS consumer) { }
|
|
|
|
private static class OfRef<T> extends EmptyNode<T, T[], Consumer<? super T>> {
|
|
private OfRef() {
|
|
super();
|
|
}
|
|
|
|
@Override
|
|
public Spliterator<T> spliterator() {
|
|
return Spliterators.emptySpliterator();
|
|
}
|
|
}
|
|
|
|
private static final class OfInt
|
|
extends EmptyNode<Integer, int[], IntConsumer>
|
|
implements Node.OfInt {
|
|
|
|
OfInt() { } // Avoid creation of special accessor
|
|
|
|
@Override
|
|
public Spliterator.OfInt spliterator() {
|
|
return Spliterators.emptyIntSpliterator();
|
|
}
|
|
|
|
@Override
|
|
public int[] asPrimitiveArray() {
|
|
return EMPTY_INT_ARRAY;
|
|
}
|
|
}
|
|
|
|
private static final class OfLong
|
|
extends EmptyNode<Long, long[], LongConsumer>
|
|
implements Node.OfLong {
|
|
|
|
OfLong() { } // Avoid creation of special accessor
|
|
|
|
@Override
|
|
public Spliterator.OfLong spliterator() {
|
|
return Spliterators.emptyLongSpliterator();
|
|
}
|
|
|
|
@Override
|
|
public long[] asPrimitiveArray() {
|
|
return EMPTY_LONG_ARRAY;
|
|
}
|
|
}
|
|
|
|
private static final class OfDouble
|
|
extends EmptyNode<Double, double[], DoubleConsumer>
|
|
implements Node.OfDouble {
|
|
|
|
OfDouble() { } // Avoid creation of special accessor
|
|
|
|
@Override
|
|
public Spliterator.OfDouble spliterator() {
|
|
return Spliterators.emptyDoubleSpliterator();
|
|
}
|
|
|
|
@Override
|
|
public double[] asPrimitiveArray() {
|
|
return EMPTY_DOUBLE_ARRAY;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Node class for a reference array */
|
|
private static class ArrayNode<T> implements Node<T> {
|
|
final T[] array;
|
|
int curSize;
|
|
|
|
@SuppressWarnings("unchecked")
|
|
ArrayNode(long size, IntFunction<T[]> generator) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
this.array = generator.apply((int) size);
|
|
this.curSize = 0;
|
|
}
|
|
|
|
ArrayNode(T[] array) {
|
|
this.array = array;
|
|
this.curSize = array.length;
|
|
}
|
|
|
|
// Node
|
|
|
|
@Override
|
|
public Spliterator<T> spliterator() {
|
|
return Arrays.spliterator(array, 0, curSize);
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(T[] dest, int destOffset) {
|
|
System.arraycopy(array, 0, dest, destOffset, curSize);
|
|
}
|
|
|
|
@Override
|
|
public T[] asArray(IntFunction<T[]> generator) {
|
|
if (array.length == curSize) {
|
|
return array;
|
|
} else {
|
|
throw new IllegalStateException();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public long count() {
|
|
return curSize;
|
|
}
|
|
|
|
@Override
|
|
public void forEach(Consumer<? super T> consumer) {
|
|
for (int i = 0; i < curSize; i++) {
|
|
consumer.accept(array[i]);
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("ArrayNode[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
/** Node class for a Collection */
|
|
private static final class CollectionNode<T> implements Node<T> {
|
|
private final Collection<T> c;
|
|
|
|
CollectionNode(Collection<T> c) {
|
|
this.c = c;
|
|
}
|
|
|
|
// Node
|
|
|
|
@Override
|
|
public Spliterator<T> spliterator() {
|
|
return c.stream().spliterator();
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(T[] array, int offset) {
|
|
for (T t : c)
|
|
array[offset++] = t;
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings("unchecked")
|
|
public T[] asArray(IntFunction<T[]> generator) {
|
|
return c.toArray(generator.apply(c.size()));
|
|
}
|
|
|
|
@Override
|
|
public long count() {
|
|
return c.size();
|
|
}
|
|
|
|
@Override
|
|
public void forEach(Consumer<? super T> consumer) {
|
|
c.forEach(consumer);
|
|
}
|
|
|
|
//
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("CollectionNode[%d][%s]", c.size(), c);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Node class for an internal node with two or more children
|
|
*/
|
|
private abstract static class AbstractConcNode<T, T_NODE extends Node<T>> implements Node<T> {
|
|
protected final T_NODE left;
|
|
protected final T_NODE right;
|
|
private final long size;
|
|
|
|
AbstractConcNode(T_NODE left, T_NODE right) {
|
|
this.left = left;
|
|
this.right = right;
|
|
// The Node count will be required when the Node spliterator is
|
|
// obtained and it is cheaper to aggressively calculate bottom up
|
|
// as the tree is built rather than later on from the top down
|
|
// traversing the tree
|
|
this.size = left.count() + right.count();
|
|
}
|
|
|
|
@Override
|
|
public int getChildCount() {
|
|
return 2;
|
|
}
|
|
|
|
@Override
|
|
public T_NODE getChild(int i) {
|
|
if (i == 0) return left;
|
|
if (i == 1) return right;
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
|
|
@Override
|
|
public long count() {
|
|
return size;
|
|
}
|
|
}
|
|
|
|
static final class ConcNode<T>
|
|
extends AbstractConcNode<T, Node<T>>
|
|
implements Node<T> {
|
|
|
|
ConcNode(Node<T> left, Node<T> right) {
|
|
super(left, right);
|
|
}
|
|
|
|
@Override
|
|
public Spliterator<T> spliterator() {
|
|
return new Nodes.InternalNodeSpliterator.OfRef<>(this);
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(T[] array, int offset) {
|
|
Objects.requireNonNull(array);
|
|
left.copyInto(array, offset);
|
|
// Cast to int is safe since it is the callers responsibility to
|
|
// ensure that there is sufficient room in the array
|
|
right.copyInto(array, offset + (int) left.count());
|
|
}
|
|
|
|
@Override
|
|
public T[] asArray(IntFunction<T[]> generator) {
|
|
long size = count();
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
T[] array = generator.apply((int) size);
|
|
copyInto(array, 0);
|
|
return array;
|
|
}
|
|
|
|
@Override
|
|
public void forEach(Consumer<? super T> consumer) {
|
|
left.forEach(consumer);
|
|
right.forEach(consumer);
|
|
}
|
|
|
|
@Override
|
|
public Node<T> truncate(long from, long to, IntFunction<T[]> generator) {
|
|
if (from == 0 && to == count())
|
|
return this;
|
|
long leftCount = left.count();
|
|
if (from >= leftCount)
|
|
return right.truncate(from - leftCount, to - leftCount, generator);
|
|
else if (to <= leftCount)
|
|
return left.truncate(from, to, generator);
|
|
else {
|
|
return Nodes.conc(getShape(), left.truncate(from, leftCount, generator),
|
|
right.truncate(0, to - leftCount, generator));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
if (count() < 32) {
|
|
return String.format("ConcNode[%s.%s]", left, right);
|
|
} else {
|
|
return String.format("ConcNode[size=%d]", count());
|
|
}
|
|
}
|
|
|
|
private abstract static class OfPrimitive<E, T_CONS, T_ARR,
|
|
T_SPLITR extends Spliterator.OfPrimitive<E, T_CONS, T_SPLITR>,
|
|
T_NODE extends Node.OfPrimitive<E, T_CONS, T_ARR, T_SPLITR, T_NODE>>
|
|
extends AbstractConcNode<E, T_NODE>
|
|
implements Node.OfPrimitive<E, T_CONS, T_ARR, T_SPLITR, T_NODE> {
|
|
|
|
OfPrimitive(T_NODE left, T_NODE right) {
|
|
super(left, right);
|
|
}
|
|
|
|
@Override
|
|
public void forEach(T_CONS consumer) {
|
|
left.forEach(consumer);
|
|
right.forEach(consumer);
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(T_ARR array, int offset) {
|
|
left.copyInto(array, offset);
|
|
// Cast to int is safe since it is the callers responsibility to
|
|
// ensure that there is sufficient room in the array
|
|
right.copyInto(array, offset + (int) left.count());
|
|
}
|
|
|
|
@Override
|
|
public T_ARR asPrimitiveArray() {
|
|
long size = count();
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
T_ARR array = newArray((int) size);
|
|
copyInto(array, 0);
|
|
return array;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
if (count() < 32)
|
|
return String.format("%s[%s.%s]", this.getClass().getName(), left, right);
|
|
else
|
|
return String.format("%s[size=%d]", this.getClass().getName(), count());
|
|
}
|
|
}
|
|
|
|
static final class OfInt
|
|
extends ConcNode.OfPrimitive<Integer, IntConsumer, int[], Spliterator.OfInt, Node.OfInt>
|
|
implements Node.OfInt {
|
|
|
|
OfInt(Node.OfInt left, Node.OfInt right) {
|
|
super(left, right);
|
|
}
|
|
|
|
@Override
|
|
public Spliterator.OfInt spliterator() {
|
|
return new InternalNodeSpliterator.OfInt(this);
|
|
}
|
|
}
|
|
|
|
static final class OfLong
|
|
extends ConcNode.OfPrimitive<Long, LongConsumer, long[], Spliterator.OfLong, Node.OfLong>
|
|
implements Node.OfLong {
|
|
|
|
OfLong(Node.OfLong left, Node.OfLong right) {
|
|
super(left, right);
|
|
}
|
|
|
|
@Override
|
|
public Spliterator.OfLong spliterator() {
|
|
return new InternalNodeSpliterator.OfLong(this);
|
|
}
|
|
}
|
|
|
|
static final class OfDouble
|
|
extends ConcNode.OfPrimitive<Double, DoubleConsumer, double[], Spliterator.OfDouble, Node.OfDouble>
|
|
implements Node.OfDouble {
|
|
|
|
OfDouble(Node.OfDouble left, Node.OfDouble right) {
|
|
super(left, right);
|
|
}
|
|
|
|
@Override
|
|
public Spliterator.OfDouble spliterator() {
|
|
return new InternalNodeSpliterator.OfDouble(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Abstract class for spliterator for all internal node classes */
|
|
private abstract static class InternalNodeSpliterator<T,
|
|
S extends Spliterator<T>,
|
|
N extends Node<T>>
|
|
implements Spliterator<T> {
|
|
// Node we are pointing to
|
|
// null if full traversal has occurred
|
|
N curNode;
|
|
|
|
// next child of curNode to consume
|
|
int curChildIndex;
|
|
|
|
// The spliterator of the curNode if that node is last and has no children.
|
|
// This spliterator will be delegated to for splitting and traversing.
|
|
// null if curNode has children
|
|
S lastNodeSpliterator;
|
|
|
|
// spliterator used while traversing with tryAdvance
|
|
// null if no partial traversal has occurred
|
|
S tryAdvanceSpliterator;
|
|
|
|
// node stack used when traversing to search and find leaf nodes
|
|
// null if no partial traversal has occurred
|
|
Deque<N> tryAdvanceStack;
|
|
|
|
InternalNodeSpliterator(N curNode) {
|
|
this.curNode = curNode;
|
|
}
|
|
|
|
/**
|
|
* Initiate a stack containing, in left-to-right order, the child nodes
|
|
* covered by this spliterator
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
protected final Deque<N> initStack() {
|
|
// Bias size to the case where leaf nodes are close to this node
|
|
// 8 is the minimum initial capacity for the ArrayDeque implementation
|
|
Deque<N> stack = new ArrayDeque<>(8);
|
|
for (int i = curNode.getChildCount() - 1; i >= curChildIndex; i--)
|
|
stack.addFirst((N) curNode.getChild(i));
|
|
return stack;
|
|
}
|
|
|
|
/**
|
|
* Depth first search, in left-to-right order, of the node tree, using
|
|
* an explicit stack, to find the next non-empty leaf node.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
protected final N findNextLeafNode(Deque<N> stack) {
|
|
N n = null;
|
|
while ((n = stack.pollFirst()) != null) {
|
|
if (n.getChildCount() == 0) {
|
|
if (n.count() > 0)
|
|
return n;
|
|
} else {
|
|
for (int i = n.getChildCount() - 1; i >= 0; i--)
|
|
stack.addFirst((N) n.getChild(i));
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
@SuppressWarnings("unchecked")
|
|
protected final boolean initTryAdvance() {
|
|
if (curNode == null)
|
|
return false;
|
|
|
|
if (tryAdvanceSpliterator == null) {
|
|
if (lastNodeSpliterator == null) {
|
|
// Initiate the node stack
|
|
tryAdvanceStack = initStack();
|
|
N leaf = findNextLeafNode(tryAdvanceStack);
|
|
if (leaf != null)
|
|
tryAdvanceSpliterator = (S) leaf.spliterator();
|
|
else {
|
|
// A non-empty leaf node was not found
|
|
// No elements to traverse
|
|
curNode = null;
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
tryAdvanceSpliterator = lastNodeSpliterator;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings("unchecked")
|
|
public final S trySplit() {
|
|
if (curNode == null || tryAdvanceSpliterator != null)
|
|
return null; // Cannot split if fully or partially traversed
|
|
else if (lastNodeSpliterator != null)
|
|
return (S) lastNodeSpliterator.trySplit();
|
|
else if (curChildIndex < curNode.getChildCount() - 1)
|
|
return (S) curNode.getChild(curChildIndex++).spliterator();
|
|
else {
|
|
curNode = (N) curNode.getChild(curChildIndex);
|
|
if (curNode.getChildCount() == 0) {
|
|
lastNodeSpliterator = (S) curNode.spliterator();
|
|
return (S) lastNodeSpliterator.trySplit();
|
|
}
|
|
else {
|
|
curChildIndex = 0;
|
|
return (S) curNode.getChild(curChildIndex++).spliterator();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public final long estimateSize() {
|
|
if (curNode == null)
|
|
return 0;
|
|
|
|
// Will not reflect the effects of partial traversal.
|
|
// This is compliant with the specification
|
|
if (lastNodeSpliterator != null)
|
|
return lastNodeSpliterator.estimateSize();
|
|
else {
|
|
long size = 0;
|
|
for (int i = curChildIndex; i < curNode.getChildCount(); i++)
|
|
size += curNode.getChild(i).count();
|
|
return size;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public final int characteristics() {
|
|
return Spliterator.SIZED;
|
|
}
|
|
|
|
private static final class OfRef<T>
|
|
extends InternalNodeSpliterator<T, Spliterator<T>, Node<T>> {
|
|
|
|
OfRef(Node<T> curNode) {
|
|
super(curNode);
|
|
}
|
|
|
|
@Override
|
|
public boolean tryAdvance(Consumer<? super T> consumer) {
|
|
if (!initTryAdvance())
|
|
return false;
|
|
|
|
boolean hasNext = tryAdvanceSpliterator.tryAdvance(consumer);
|
|
if (!hasNext) {
|
|
if (lastNodeSpliterator == null) {
|
|
// Advance to the spliterator of the next non-empty leaf node
|
|
Node<T> leaf = findNextLeafNode(tryAdvanceStack);
|
|
if (leaf != null) {
|
|
tryAdvanceSpliterator = leaf.spliterator();
|
|
// Since the node is not-empty the spliterator can be advanced
|
|
return tryAdvanceSpliterator.tryAdvance(consumer);
|
|
}
|
|
}
|
|
// No more elements to traverse
|
|
curNode = null;
|
|
}
|
|
return hasNext;
|
|
}
|
|
|
|
@Override
|
|
public void forEachRemaining(Consumer<? super T> consumer) {
|
|
if (curNode == null)
|
|
return;
|
|
|
|
if (tryAdvanceSpliterator == null) {
|
|
if (lastNodeSpliterator == null) {
|
|
Deque<Node<T>> stack = initStack();
|
|
Node<T> leaf;
|
|
while ((leaf = findNextLeafNode(stack)) != null) {
|
|
leaf.forEach(consumer);
|
|
}
|
|
curNode = null;
|
|
}
|
|
else
|
|
lastNodeSpliterator.forEachRemaining(consumer);
|
|
}
|
|
else
|
|
while(tryAdvance(consumer)) { }
|
|
}
|
|
}
|
|
|
|
private abstract static class OfPrimitive<T, T_CONS, T_ARR,
|
|
T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>,
|
|
N extends Node.OfPrimitive<T, T_CONS, T_ARR, T_SPLITR, N>>
|
|
extends InternalNodeSpliterator<T, T_SPLITR, N>
|
|
implements Spliterator.OfPrimitive<T, T_CONS, T_SPLITR> {
|
|
|
|
OfPrimitive(N cur) {
|
|
super(cur);
|
|
}
|
|
|
|
@Override
|
|
public boolean tryAdvance(T_CONS consumer) {
|
|
if (!initTryAdvance())
|
|
return false;
|
|
|
|
boolean hasNext = tryAdvanceSpliterator.tryAdvance(consumer);
|
|
if (!hasNext) {
|
|
if (lastNodeSpliterator == null) {
|
|
// Advance to the spliterator of the next non-empty leaf node
|
|
N leaf = findNextLeafNode(tryAdvanceStack);
|
|
if (leaf != null) {
|
|
tryAdvanceSpliterator = leaf.spliterator();
|
|
// Since the node is not-empty the spliterator can be advanced
|
|
return tryAdvanceSpliterator.tryAdvance(consumer);
|
|
}
|
|
}
|
|
// No more elements to traverse
|
|
curNode = null;
|
|
}
|
|
return hasNext;
|
|
}
|
|
|
|
@Override
|
|
public void forEachRemaining(T_CONS consumer) {
|
|
if (curNode == null)
|
|
return;
|
|
|
|
if (tryAdvanceSpliterator == null) {
|
|
if (lastNodeSpliterator == null) {
|
|
Deque<N> stack = initStack();
|
|
N leaf;
|
|
while ((leaf = findNextLeafNode(stack)) != null) {
|
|
leaf.forEach(consumer);
|
|
}
|
|
curNode = null;
|
|
}
|
|
else
|
|
lastNodeSpliterator.forEachRemaining(consumer);
|
|
}
|
|
else
|
|
while(tryAdvance(consumer)) { }
|
|
}
|
|
}
|
|
|
|
private static final class OfInt
|
|
extends OfPrimitive<Integer, IntConsumer, int[], Spliterator.OfInt, Node.OfInt>
|
|
implements Spliterator.OfInt {
|
|
|
|
OfInt(Node.OfInt cur) {
|
|
super(cur);
|
|
}
|
|
}
|
|
|
|
private static final class OfLong
|
|
extends OfPrimitive<Long, LongConsumer, long[], Spliterator.OfLong, Node.OfLong>
|
|
implements Spliterator.OfLong {
|
|
|
|
OfLong(Node.OfLong cur) {
|
|
super(cur);
|
|
}
|
|
}
|
|
|
|
private static final class OfDouble
|
|
extends OfPrimitive<Double, DoubleConsumer, double[], Spliterator.OfDouble, Node.OfDouble>
|
|
implements Spliterator.OfDouble {
|
|
|
|
OfDouble(Node.OfDouble cur) {
|
|
super(cur);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fixed-sized builder class for reference nodes
|
|
*/
|
|
private static final class FixedNodeBuilder<T>
|
|
extends ArrayNode<T>
|
|
implements Node.Builder<T> {
|
|
|
|
FixedNodeBuilder(long size, IntFunction<T[]> generator) {
|
|
super(size, generator);
|
|
assert size < MAX_ARRAY_SIZE;
|
|
}
|
|
|
|
@Override
|
|
public Node<T> build() {
|
|
if (curSize < array.length)
|
|
throw new IllegalStateException(String.format("Current size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public void begin(long size) {
|
|
if (size != array.length)
|
|
throw new IllegalStateException(String.format("Begin size %d is not equal to fixed size %d",
|
|
size, array.length));
|
|
curSize = 0;
|
|
}
|
|
|
|
@Override
|
|
public void accept(T t) {
|
|
if (curSize < array.length) {
|
|
array[curSize++] = t;
|
|
} else {
|
|
throw new IllegalStateException(String.format("Accept exceeded fixed size of %d",
|
|
array.length));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
if (curSize < array.length)
|
|
throw new IllegalStateException(String.format("End size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("FixedNodeBuilder[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Variable-sized builder class for reference nodes
|
|
*/
|
|
private static final class SpinedNodeBuilder<T>
|
|
extends SpinedBuffer<T>
|
|
implements Node<T>, Node.Builder<T> {
|
|
private boolean building = false;
|
|
|
|
SpinedNodeBuilder() {} // Avoid creation of special accessor
|
|
|
|
@Override
|
|
public Spliterator<T> spliterator() {
|
|
assert !building : "during building";
|
|
return super.spliterator();
|
|
}
|
|
|
|
@Override
|
|
public void forEach(Consumer<? super T> consumer) {
|
|
assert !building : "during building";
|
|
super.forEach(consumer);
|
|
}
|
|
|
|
//
|
|
@Override
|
|
public void begin(long size) {
|
|
assert !building : "was already building";
|
|
building = true;
|
|
clear();
|
|
ensureCapacity(size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(T t) {
|
|
assert building : "not building";
|
|
super.accept(t);
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
assert building : "was not building";
|
|
building = false;
|
|
// @@@ check begin(size) and size
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(T[] array, int offset) {
|
|
assert !building : "during building";
|
|
super.copyInto(array, offset);
|
|
}
|
|
|
|
@Override
|
|
public T[] asArray(IntFunction<T[]> arrayFactory) {
|
|
assert !building : "during building";
|
|
return super.asArray(arrayFactory);
|
|
}
|
|
|
|
@Override
|
|
public Node<T> build() {
|
|
assert !building : "during building";
|
|
return this;
|
|
}
|
|
}
|
|
|
|
//
|
|
|
|
private static final int[] EMPTY_INT_ARRAY = new int[0];
|
|
private static final long[] EMPTY_LONG_ARRAY = new long[0];
|
|
private static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
|
|
|
|
private static class IntArrayNode implements Node.OfInt {
|
|
final int[] array;
|
|
int curSize;
|
|
|
|
IntArrayNode(long size) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
this.array = new int[(int) size];
|
|
this.curSize = 0;
|
|
}
|
|
|
|
IntArrayNode(int[] array) {
|
|
this.array = array;
|
|
this.curSize = array.length;
|
|
}
|
|
|
|
// Node
|
|
|
|
@Override
|
|
public Spliterator.OfInt spliterator() {
|
|
return Arrays.spliterator(array, 0, curSize);
|
|
}
|
|
|
|
@Override
|
|
public int[] asPrimitiveArray() {
|
|
if (array.length == curSize) {
|
|
return array;
|
|
} else {
|
|
return Arrays.copyOf(array, curSize);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(int[] dest, int destOffset) {
|
|
System.arraycopy(array, 0, dest, destOffset, curSize);
|
|
}
|
|
|
|
@Override
|
|
public long count() {
|
|
return curSize;
|
|
}
|
|
|
|
@Override
|
|
public void forEach(IntConsumer consumer) {
|
|
for (int i = 0; i < curSize; i++) {
|
|
consumer.accept(array[i]);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("IntArrayNode[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
private static class LongArrayNode implements Node.OfLong {
|
|
final long[] array;
|
|
int curSize;
|
|
|
|
LongArrayNode(long size) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
this.array = new long[(int) size];
|
|
this.curSize = 0;
|
|
}
|
|
|
|
LongArrayNode(long[] array) {
|
|
this.array = array;
|
|
this.curSize = array.length;
|
|
}
|
|
|
|
@Override
|
|
public Spliterator.OfLong spliterator() {
|
|
return Arrays.spliterator(array, 0, curSize);
|
|
}
|
|
|
|
@Override
|
|
public long[] asPrimitiveArray() {
|
|
if (array.length == curSize) {
|
|
return array;
|
|
} else {
|
|
return Arrays.copyOf(array, curSize);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(long[] dest, int destOffset) {
|
|
System.arraycopy(array, 0, dest, destOffset, curSize);
|
|
}
|
|
|
|
@Override
|
|
public long count() {
|
|
return curSize;
|
|
}
|
|
|
|
@Override
|
|
public void forEach(LongConsumer consumer) {
|
|
for (int i = 0; i < curSize; i++) {
|
|
consumer.accept(array[i]);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("LongArrayNode[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
private static class DoubleArrayNode implements Node.OfDouble {
|
|
final double[] array;
|
|
int curSize;
|
|
|
|
DoubleArrayNode(long size) {
|
|
if (size >= MAX_ARRAY_SIZE)
|
|
throw new IllegalArgumentException(BAD_SIZE);
|
|
this.array = new double[(int) size];
|
|
this.curSize = 0;
|
|
}
|
|
|
|
DoubleArrayNode(double[] array) {
|
|
this.array = array;
|
|
this.curSize = array.length;
|
|
}
|
|
|
|
@Override
|
|
public Spliterator.OfDouble spliterator() {
|
|
return Arrays.spliterator(array, 0, curSize);
|
|
}
|
|
|
|
@Override
|
|
public double[] asPrimitiveArray() {
|
|
if (array.length == curSize) {
|
|
return array;
|
|
} else {
|
|
return Arrays.copyOf(array, curSize);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(double[] dest, int destOffset) {
|
|
System.arraycopy(array, 0, dest, destOffset, curSize);
|
|
}
|
|
|
|
@Override
|
|
public long count() {
|
|
return curSize;
|
|
}
|
|
|
|
@Override
|
|
public void forEach(DoubleConsumer consumer) {
|
|
for (int i = 0; i < curSize; i++) {
|
|
consumer.accept(array[i]);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("DoubleArrayNode[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
private static final class IntFixedNodeBuilder
|
|
extends IntArrayNode
|
|
implements Node.Builder.OfInt {
|
|
|
|
IntFixedNodeBuilder(long size) {
|
|
super(size);
|
|
assert size < MAX_ARRAY_SIZE;
|
|
}
|
|
|
|
@Override
|
|
public Node.OfInt build() {
|
|
if (curSize < array.length) {
|
|
throw new IllegalStateException(String.format("Current size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public void begin(long size) {
|
|
if (size != array.length) {
|
|
throw new IllegalStateException(String.format("Begin size %d is not equal to fixed size %d",
|
|
size, array.length));
|
|
}
|
|
|
|
curSize = 0;
|
|
}
|
|
|
|
@Override
|
|
public void accept(int i) {
|
|
if (curSize < array.length) {
|
|
array[curSize++] = i;
|
|
} else {
|
|
throw new IllegalStateException(String.format("Accept exceeded fixed size of %d",
|
|
array.length));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
if (curSize < array.length) {
|
|
throw new IllegalStateException(String.format("End size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("IntFixedNodeBuilder[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
private static final class LongFixedNodeBuilder
|
|
extends LongArrayNode
|
|
implements Node.Builder.OfLong {
|
|
|
|
LongFixedNodeBuilder(long size) {
|
|
super(size);
|
|
assert size < MAX_ARRAY_SIZE;
|
|
}
|
|
|
|
@Override
|
|
public Node.OfLong build() {
|
|
if (curSize < array.length) {
|
|
throw new IllegalStateException(String.format("Current size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public void begin(long size) {
|
|
if (size != array.length) {
|
|
throw new IllegalStateException(String.format("Begin size %d is not equal to fixed size %d",
|
|
size, array.length));
|
|
}
|
|
|
|
curSize = 0;
|
|
}
|
|
|
|
@Override
|
|
public void accept(long i) {
|
|
if (curSize < array.length) {
|
|
array[curSize++] = i;
|
|
} else {
|
|
throw new IllegalStateException(String.format("Accept exceeded fixed size of %d",
|
|
array.length));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
if (curSize < array.length) {
|
|
throw new IllegalStateException(String.format("End size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("LongFixedNodeBuilder[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
private static final class DoubleFixedNodeBuilder
|
|
extends DoubleArrayNode
|
|
implements Node.Builder.OfDouble {
|
|
|
|
DoubleFixedNodeBuilder(long size) {
|
|
super(size);
|
|
assert size < MAX_ARRAY_SIZE;
|
|
}
|
|
|
|
@Override
|
|
public Node.OfDouble build() {
|
|
if (curSize < array.length) {
|
|
throw new IllegalStateException(String.format("Current size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
@Override
|
|
public void begin(long size) {
|
|
if (size != array.length) {
|
|
throw new IllegalStateException(String.format("Begin size %d is not equal to fixed size %d",
|
|
size, array.length));
|
|
}
|
|
|
|
curSize = 0;
|
|
}
|
|
|
|
@Override
|
|
public void accept(double i) {
|
|
if (curSize < array.length) {
|
|
array[curSize++] = i;
|
|
} else {
|
|
throw new IllegalStateException(String.format("Accept exceeded fixed size of %d",
|
|
array.length));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
if (curSize < array.length) {
|
|
throw new IllegalStateException(String.format("End size %d is less than fixed size %d",
|
|
curSize, array.length));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return String.format("DoubleFixedNodeBuilder[%d][%s]",
|
|
array.length - curSize, Arrays.toString(array));
|
|
}
|
|
}
|
|
|
|
private static final class IntSpinedNodeBuilder
|
|
extends SpinedBuffer.OfInt
|
|
implements Node.OfInt, Node.Builder.OfInt {
|
|
private boolean building = false;
|
|
|
|
IntSpinedNodeBuilder() {} // Avoid creation of special accessor
|
|
|
|
@Override
|
|
public Spliterator.OfInt spliterator() {
|
|
assert !building : "during building";
|
|
return super.spliterator();
|
|
}
|
|
|
|
@Override
|
|
public void forEach(IntConsumer consumer) {
|
|
assert !building : "during building";
|
|
super.forEach(consumer);
|
|
}
|
|
|
|
//
|
|
@Override
|
|
public void begin(long size) {
|
|
assert !building : "was already building";
|
|
building = true;
|
|
clear();
|
|
ensureCapacity(size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(int i) {
|
|
assert building : "not building";
|
|
super.accept(i);
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
assert building : "was not building";
|
|
building = false;
|
|
// @@@ check begin(size) and size
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(int[] array, int offset) throws IndexOutOfBoundsException {
|
|
assert !building : "during building";
|
|
super.copyInto(array, offset);
|
|
}
|
|
|
|
@Override
|
|
public int[] asPrimitiveArray() {
|
|
assert !building : "during building";
|
|
return super.asPrimitiveArray();
|
|
}
|
|
|
|
@Override
|
|
public Node.OfInt build() {
|
|
assert !building : "during building";
|
|
return this;
|
|
}
|
|
}
|
|
|
|
private static final class LongSpinedNodeBuilder
|
|
extends SpinedBuffer.OfLong
|
|
implements Node.OfLong, Node.Builder.OfLong {
|
|
private boolean building = false;
|
|
|
|
LongSpinedNodeBuilder() {} // Avoid creation of special accessor
|
|
|
|
@Override
|
|
public Spliterator.OfLong spliterator() {
|
|
assert !building : "during building";
|
|
return super.spliterator();
|
|
}
|
|
|
|
@Override
|
|
public void forEach(LongConsumer consumer) {
|
|
assert !building : "during building";
|
|
super.forEach(consumer);
|
|
}
|
|
|
|
//
|
|
@Override
|
|
public void begin(long size) {
|
|
assert !building : "was already building";
|
|
building = true;
|
|
clear();
|
|
ensureCapacity(size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(long i) {
|
|
assert building : "not building";
|
|
super.accept(i);
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
assert building : "was not building";
|
|
building = false;
|
|
// @@@ check begin(size) and size
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(long[] array, int offset) {
|
|
assert !building : "during building";
|
|
super.copyInto(array, offset);
|
|
}
|
|
|
|
@Override
|
|
public long[] asPrimitiveArray() {
|
|
assert !building : "during building";
|
|
return super.asPrimitiveArray();
|
|
}
|
|
|
|
@Override
|
|
public Node.OfLong build() {
|
|
assert !building : "during building";
|
|
return this;
|
|
}
|
|
}
|
|
|
|
private static final class DoubleSpinedNodeBuilder
|
|
extends SpinedBuffer.OfDouble
|
|
implements Node.OfDouble, Node.Builder.OfDouble {
|
|
private boolean building = false;
|
|
|
|
DoubleSpinedNodeBuilder() {} // Avoid creation of special accessor
|
|
|
|
@Override
|
|
public Spliterator.OfDouble spliterator() {
|
|
assert !building : "during building";
|
|
return super.spliterator();
|
|
}
|
|
|
|
@Override
|
|
public void forEach(DoubleConsumer consumer) {
|
|
assert !building : "during building";
|
|
super.forEach(consumer);
|
|
}
|
|
|
|
//
|
|
@Override
|
|
public void begin(long size) {
|
|
assert !building : "was already building";
|
|
building = true;
|
|
clear();
|
|
ensureCapacity(size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(double i) {
|
|
assert building : "not building";
|
|
super.accept(i);
|
|
}
|
|
|
|
@Override
|
|
public void end() {
|
|
assert building : "was not building";
|
|
building = false;
|
|
// @@@ check begin(size) and size
|
|
}
|
|
|
|
@Override
|
|
public void copyInto(double[] array, int offset) {
|
|
assert !building : "during building";
|
|
super.copyInto(array, offset);
|
|
}
|
|
|
|
@Override
|
|
public double[] asPrimitiveArray() {
|
|
assert !building : "during building";
|
|
return super.asPrimitiveArray();
|
|
}
|
|
|
|
@Override
|
|
public Node.OfDouble build() {
|
|
assert !building : "during building";
|
|
return this;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This and subclasses are not intended to be serializable
|
|
*/
|
|
@SuppressWarnings("serial")
|
|
private abstract static class SizedCollectorTask<P_IN, P_OUT, T_SINK extends Sink<P_OUT>,
|
|
K extends SizedCollectorTask<P_IN, P_OUT, T_SINK, K>>
|
|
extends CountedCompleter<Void>
|
|
implements Sink<P_OUT> {
|
|
protected final Spliterator<P_IN> spliterator;
|
|
protected final PipelineHelper<P_OUT> helper;
|
|
protected final long targetSize;
|
|
protected long offset;
|
|
protected long length;
|
|
// For Sink implementation
|
|
protected int index, fence;
|
|
|
|
SizedCollectorTask(Spliterator<P_IN> spliterator,
|
|
PipelineHelper<P_OUT> helper,
|
|
int arrayLength) {
|
|
assert spliterator.hasCharacteristics(Spliterator.SUBSIZED);
|
|
this.spliterator = spliterator;
|
|
this.helper = helper;
|
|
this.targetSize = AbstractTask.suggestTargetSize(spliterator.estimateSize());
|
|
this.offset = 0;
|
|
this.length = arrayLength;
|
|
}
|
|
|
|
SizedCollectorTask(K parent, Spliterator<P_IN> spliterator,
|
|
long offset, long length, int arrayLength) {
|
|
super(parent);
|
|
assert spliterator.hasCharacteristics(Spliterator.SUBSIZED);
|
|
this.spliterator = spliterator;
|
|
this.helper = parent.helper;
|
|
this.targetSize = parent.targetSize;
|
|
this.offset = offset;
|
|
this.length = length;
|
|
|
|
if (offset < 0 || length < 0 || (offset + length - 1 >= arrayLength)) {
|
|
throw new IllegalArgumentException(
|
|
String.format("offset and length interval [%d, %d + %d) is not within array size interval [0, %d)",
|
|
offset, offset, length, arrayLength));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void compute() {
|
|
SizedCollectorTask<P_IN, P_OUT, T_SINK, K> task = this;
|
|
Spliterator<P_IN> rightSplit = spliterator, leftSplit;
|
|
while (rightSplit.estimateSize() > task.targetSize &&
|
|
(leftSplit = rightSplit.trySplit()) != null) {
|
|
task.setPendingCount(1);
|
|
long leftSplitSize = leftSplit.estimateSize();
|
|
task.makeChild(leftSplit, task.offset, leftSplitSize).fork();
|
|
task = task.makeChild(rightSplit, task.offset + leftSplitSize,
|
|
task.length - leftSplitSize);
|
|
}
|
|
|
|
assert task.offset + task.length < MAX_ARRAY_SIZE;
|
|
@SuppressWarnings("unchecked")
|
|
T_SINK sink = (T_SINK) task;
|
|
task.helper.wrapAndCopyInto(sink, rightSplit);
|
|
task.propagateCompletion();
|
|
}
|
|
|
|
abstract K makeChild(Spliterator<P_IN> spliterator, long offset, long size);
|
|
|
|
@Override
|
|
public void begin(long size) {
|
|
if (size > length)
|
|
throw new IllegalStateException("size passed to Sink.begin exceeds array length");
|
|
// Casts to int are safe since absolute size is verified to be within
|
|
// bounds when the root concrete SizedCollectorTask is constructed
|
|
// with the shared array
|
|
index = (int) offset;
|
|
fence = index + (int) length;
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
static final class OfRef<P_IN, P_OUT>
|
|
extends SizedCollectorTask<P_IN, P_OUT, Sink<P_OUT>, OfRef<P_IN, P_OUT>>
|
|
implements Sink<P_OUT> {
|
|
private final P_OUT[] array;
|
|
|
|
OfRef(Spliterator<P_IN> spliterator, PipelineHelper<P_OUT> helper, P_OUT[] array) {
|
|
super(spliterator, helper, array.length);
|
|
this.array = array;
|
|
}
|
|
|
|
OfRef(OfRef<P_IN, P_OUT> parent, Spliterator<P_IN> spliterator,
|
|
long offset, long length) {
|
|
super(parent, spliterator, offset, length, parent.array.length);
|
|
this.array = parent.array;
|
|
}
|
|
|
|
@Override
|
|
OfRef<P_IN, P_OUT> makeChild(Spliterator<P_IN> spliterator,
|
|
long offset, long size) {
|
|
return new OfRef<>(this, spliterator, offset, size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(P_OUT value) {
|
|
if (index >= fence) {
|
|
throw new IndexOutOfBoundsException(Integer.toString(index));
|
|
}
|
|
array[index++] = value;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
static final class OfInt<P_IN>
|
|
extends SizedCollectorTask<P_IN, Integer, Sink.OfInt, OfInt<P_IN>>
|
|
implements Sink.OfInt {
|
|
private final int[] array;
|
|
|
|
OfInt(Spliterator<P_IN> spliterator, PipelineHelper<Integer> helper, int[] array) {
|
|
super(spliterator, helper, array.length);
|
|
this.array = array;
|
|
}
|
|
|
|
OfInt(SizedCollectorTask.OfInt<P_IN> parent, Spliterator<P_IN> spliterator,
|
|
long offset, long length) {
|
|
super(parent, spliterator, offset, length, parent.array.length);
|
|
this.array = parent.array;
|
|
}
|
|
|
|
@Override
|
|
SizedCollectorTask.OfInt<P_IN> makeChild(Spliterator<P_IN> spliterator,
|
|
long offset, long size) {
|
|
return new SizedCollectorTask.OfInt<>(this, spliterator, offset, size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(int value) {
|
|
if (index >= fence) {
|
|
throw new IndexOutOfBoundsException(Integer.toString(index));
|
|
}
|
|
array[index++] = value;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
static final class OfLong<P_IN>
|
|
extends SizedCollectorTask<P_IN, Long, Sink.OfLong, OfLong<P_IN>>
|
|
implements Sink.OfLong {
|
|
private final long[] array;
|
|
|
|
OfLong(Spliterator<P_IN> spliterator, PipelineHelper<Long> helper, long[] array) {
|
|
super(spliterator, helper, array.length);
|
|
this.array = array;
|
|
}
|
|
|
|
OfLong(SizedCollectorTask.OfLong<P_IN> parent, Spliterator<P_IN> spliterator,
|
|
long offset, long length) {
|
|
super(parent, spliterator, offset, length, parent.array.length);
|
|
this.array = parent.array;
|
|
}
|
|
|
|
@Override
|
|
SizedCollectorTask.OfLong<P_IN> makeChild(Spliterator<P_IN> spliterator,
|
|
long offset, long size) {
|
|
return new SizedCollectorTask.OfLong<>(this, spliterator, offset, size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(long value) {
|
|
if (index >= fence) {
|
|
throw new IndexOutOfBoundsException(Integer.toString(index));
|
|
}
|
|
array[index++] = value;
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
static final class OfDouble<P_IN>
|
|
extends SizedCollectorTask<P_IN, Double, Sink.OfDouble, OfDouble<P_IN>>
|
|
implements Sink.OfDouble {
|
|
private final double[] array;
|
|
|
|
OfDouble(Spliterator<P_IN> spliterator, PipelineHelper<Double> helper, double[] array) {
|
|
super(spliterator, helper, array.length);
|
|
this.array = array;
|
|
}
|
|
|
|
OfDouble(SizedCollectorTask.OfDouble<P_IN> parent, Spliterator<P_IN> spliterator,
|
|
long offset, long length) {
|
|
super(parent, spliterator, offset, length, parent.array.length);
|
|
this.array = parent.array;
|
|
}
|
|
|
|
@Override
|
|
SizedCollectorTask.OfDouble<P_IN> makeChild(Spliterator<P_IN> spliterator,
|
|
long offset, long size) {
|
|
return new SizedCollectorTask.OfDouble<>(this, spliterator, offset, size);
|
|
}
|
|
|
|
@Override
|
|
public void accept(double value) {
|
|
if (index >= fence) {
|
|
throw new IndexOutOfBoundsException(Integer.toString(index));
|
|
}
|
|
array[index++] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private abstract static class ToArrayTask<T, T_NODE extends Node<T>,
|
|
K extends ToArrayTask<T, T_NODE, K>>
|
|
extends CountedCompleter<Void> {
|
|
protected final T_NODE node;
|
|
protected final int offset;
|
|
|
|
ToArrayTask(T_NODE node, int offset) {
|
|
this.node = node;
|
|
this.offset = offset;
|
|
}
|
|
|
|
ToArrayTask(K parent, T_NODE node, int offset) {
|
|
super(parent);
|
|
this.node = node;
|
|
this.offset = offset;
|
|
}
|
|
|
|
abstract void copyNodeToArray();
|
|
|
|
abstract K makeChild(int childIndex, int offset);
|
|
|
|
@Override
|
|
public void compute() {
|
|
ToArrayTask<T, T_NODE, K> task = this;
|
|
while (true) {
|
|
if (task.node.getChildCount() == 0) {
|
|
task.copyNodeToArray();
|
|
task.propagateCompletion();
|
|
return;
|
|
}
|
|
else {
|
|
task.setPendingCount(task.node.getChildCount() - 1);
|
|
|
|
int size = 0;
|
|
int i = 0;
|
|
for (;i < task.node.getChildCount() - 1; i++) {
|
|
K leftTask = task.makeChild(i, task.offset + size);
|
|
size += leftTask.node.count();
|
|
leftTask.fork();
|
|
}
|
|
task = task.makeChild(i, task.offset + size);
|
|
}
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfRef<T>
|
|
extends ToArrayTask<T, Node<T>, OfRef<T>> {
|
|
private final T[] array;
|
|
|
|
private OfRef(Node<T> node, T[] array, int offset) {
|
|
super(node, offset);
|
|
this.array = array;
|
|
}
|
|
|
|
private OfRef(OfRef<T> parent, Node<T> node, int offset) {
|
|
super(parent, node, offset);
|
|
this.array = parent.array;
|
|
}
|
|
|
|
@Override
|
|
OfRef<T> makeChild(int childIndex, int offset) {
|
|
return new OfRef<>(this, node.getChild(childIndex), offset);
|
|
}
|
|
|
|
@Override
|
|
void copyNodeToArray() {
|
|
node.copyInto(array, offset);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static class OfPrimitive<T, T_CONS, T_ARR,
|
|
T_SPLITR extends Spliterator.OfPrimitive<T, T_CONS, T_SPLITR>,
|
|
T_NODE extends Node.OfPrimitive<T, T_CONS, T_ARR, T_SPLITR, T_NODE>>
|
|
extends ToArrayTask<T, T_NODE, OfPrimitive<T, T_CONS, T_ARR, T_SPLITR, T_NODE>> {
|
|
private final T_ARR array;
|
|
|
|
private OfPrimitive(T_NODE node, T_ARR array, int offset) {
|
|
super(node, offset);
|
|
this.array = array;
|
|
}
|
|
|
|
private OfPrimitive(OfPrimitive<T, T_CONS, T_ARR, T_SPLITR, T_NODE> parent, T_NODE node, int offset) {
|
|
super(parent, node, offset);
|
|
this.array = parent.array;
|
|
}
|
|
|
|
@Override
|
|
OfPrimitive<T, T_CONS, T_ARR, T_SPLITR, T_NODE> makeChild(int childIndex, int offset) {
|
|
return new OfPrimitive<>(this, node.getChild(childIndex), offset);
|
|
}
|
|
|
|
@Override
|
|
void copyNodeToArray() {
|
|
node.copyInto(array, offset);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfInt
|
|
extends OfPrimitive<Integer, IntConsumer, int[], Spliterator.OfInt, Node.OfInt> {
|
|
private OfInt(Node.OfInt node, int[] array, int offset) {
|
|
super(node, array, offset);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfLong
|
|
extends OfPrimitive<Long, LongConsumer, long[], Spliterator.OfLong, Node.OfLong> {
|
|
private OfLong(Node.OfLong node, long[] array, int offset) {
|
|
super(node, array, offset);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfDouble
|
|
extends OfPrimitive<Double, DoubleConsumer, double[], Spliterator.OfDouble, Node.OfDouble> {
|
|
private OfDouble(Node.OfDouble node, double[] array, int offset) {
|
|
super(node, array, offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static class CollectorTask<P_IN, P_OUT, T_NODE extends Node<P_OUT>, T_BUILDER extends Node.Builder<P_OUT>>
|
|
extends AbstractTask<P_IN, P_OUT, T_NODE, CollectorTask<P_IN, P_OUT, T_NODE, T_BUILDER>> {
|
|
protected final PipelineHelper<P_OUT> helper;
|
|
protected final LongFunction<T_BUILDER> builderFactory;
|
|
protected final BinaryOperator<T_NODE> concFactory;
|
|
|
|
CollectorTask(PipelineHelper<P_OUT> helper,
|
|
Spliterator<P_IN> spliterator,
|
|
LongFunction<T_BUILDER> builderFactory,
|
|
BinaryOperator<T_NODE> concFactory) {
|
|
super(helper, spliterator);
|
|
this.helper = helper;
|
|
this.builderFactory = builderFactory;
|
|
this.concFactory = concFactory;
|
|
}
|
|
|
|
CollectorTask(CollectorTask<P_IN, P_OUT, T_NODE, T_BUILDER> parent,
|
|
Spliterator<P_IN> spliterator) {
|
|
super(parent, spliterator);
|
|
helper = parent.helper;
|
|
builderFactory = parent.builderFactory;
|
|
concFactory = parent.concFactory;
|
|
}
|
|
|
|
@Override
|
|
protected CollectorTask<P_IN, P_OUT, T_NODE, T_BUILDER> makeChild(Spliterator<P_IN> spliterator) {
|
|
return new CollectorTask<>(this, spliterator);
|
|
}
|
|
|
|
@Override
|
|
@SuppressWarnings("unchecked")
|
|
protected T_NODE doLeaf() {
|
|
T_BUILDER builder = builderFactory.apply(helper.exactOutputSizeIfKnown(spliterator));
|
|
return (T_NODE) helper.wrapAndCopyInto(builder, spliterator).build();
|
|
}
|
|
|
|
@Override
|
|
public void onCompletion(CountedCompleter<?> caller) {
|
|
if (!isLeaf())
|
|
setLocalResult(concFactory.apply(leftChild.getLocalResult(), rightChild.getLocalResult()));
|
|
super.onCompletion(caller);
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfRef<P_IN, P_OUT>
|
|
extends CollectorTask<P_IN, P_OUT, Node<P_OUT>, Node.Builder<P_OUT>> {
|
|
OfRef(PipelineHelper<P_OUT> helper,
|
|
IntFunction<P_OUT[]> generator,
|
|
Spliterator<P_IN> spliterator) {
|
|
super(helper, spliterator, s -> builder(s, generator), ConcNode::new);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfInt<P_IN>
|
|
extends CollectorTask<P_IN, Integer, Node.OfInt, Node.Builder.OfInt> {
|
|
OfInt(PipelineHelper<Integer> helper, Spliterator<P_IN> spliterator) {
|
|
super(helper, spliterator, Nodes::intBuilder, ConcNode.OfInt::new);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfLong<P_IN>
|
|
extends CollectorTask<P_IN, Long, Node.OfLong, Node.Builder.OfLong> {
|
|
OfLong(PipelineHelper<Long> helper, Spliterator<P_IN> spliterator) {
|
|
super(helper, spliterator, Nodes::longBuilder, ConcNode.OfLong::new);
|
|
}
|
|
}
|
|
|
|
@SuppressWarnings("serial")
|
|
private static final class OfDouble<P_IN>
|
|
extends CollectorTask<P_IN, Double, Node.OfDouble, Node.Builder.OfDouble> {
|
|
OfDouble(PipelineHelper<Double> helper, Spliterator<P_IN> spliterator) {
|
|
super(helper, spliterator, Nodes::doubleBuilder, ConcNode.OfDouble::new);
|
|
}
|
|
}
|
|
}
|
|
}
|