terminal

type AbstractPipeline struct {
	class.Class
	// contains filtered or unexported fields
}

type Operation interface {
	/**
	 * Gets the stream flags of the operation.  Terminal operations may set a
	 * limited subset of the stream flags defined in {@link StreamOpFlag}, and
	 * these flags are combined with the previously combined stream and
	 * intermediate operation flags for the pipeline.
	 *
	 * @implSpec The default implementation returns zero.
	 *
	 * @return the stream flags for this operation
	 * @see StreamOpFlag
	 */
	GetOpFlags() int

	/**
	 * Performs a parallel evaluation of the operation using the specified
	 * {@code PipelineHelper}, which describes the upstream intermediate
	 * operations.
	 *
	 * @implSpec The default performs a sequential evaluation of the operation
	 * using the specified {@code PipelineHelper}.
	 *
	 * @param helper the pipeline helper
	 * @param spliterator the source spliterator
	 * @return the result of the evaluation
	 */
	EvaluateParallel(ctx context.Context, spliterator spliterator.Spliterator) optional.Optional

	/**
	 * Performs a sequential evaluation of the operation using the specified
	 * {@code PipelineHelper}, which describes the upstream intermediate
	 * operations.
	 *
	 * @param helper the pipeline helper
	 * @param spliterator the source spliterator
	 * @return the result of the evaluation
	 */
	EvaluateSequential(ctx context.Context, spliterator spliterator.Spliterator) optional.Optional
}

type ShortCircuitTask interface {
	Task

	SharedResult() *sharedResult
	/**
	 * The result for this computation; this is shared among all tasks and set
	 * exactly once
	 */
	GetSharedResult() Sink

	/**
	 * Declares that a globally valid result has been found.  If another task has
	 * not already found the answer, the result is installed in
	 * {@code sharedResult}.  The {@code compute()} method will check
	 * {@code sharedResult} before proceeding with computation, so this causes
	 * the computation to terminate early.
	 *
	 * @param result the result found
	 */
	ShortCircuit(result Sink)

	/**
	 * Mark this task as canceled
	 */
	Cancel()

	/**
	 * Queries whether this task is canceled.  A task is considered canceled if
	 * it or any of its parents have been canceled.
	 *
	 * @return {@code true} if this task or any parent is canceled.
	 */
	TaskCanceled() bool

	/**
	 * Cancels all tasks which succeed this one in the encounter order.  This
	 * includes canceling all the current task's right sibling, as well as the
	 * later right siblings of all its parents.
	 */
	CancelLaterNodes()
}

type Sink interface {
	sink.Sink
	supplier.OptionalSupplier
}

type TODOOperation struct {
	class.Class
}

type TODOShortCircuitTask struct {
	TODOTask
	// contains filtered or unexported fields
}

type TODOSink struct {
	sink.TODO
}

type TODOTask struct {
	class.Class
	// contains filtered or unexported fields
}

type Task interface {
	GetSpliterator() spliterator.Spliterator
	/**
	 * Returns the parent of this task, or null if this task is the root
	 *
	 * @return the parent of this task, or null if this task is the root
	 */
	GetParent() Task

	/**
	 * The left child.
	 * null if no children
	 * if non-null rightChild is non-null
	 *
	 * @return the right child
	 */
	LeftChild() Task

	SetLeftChild(task Task)

	/**
	 * The right child.
	 * null if no children
	 * if non-null rightChild is non-null
	 *
	 * @return the right child
	 */
	RightChild() Task

	SetRightChild(task Task)

	/**
	 * Indicates whether this task is a leaf node.  (Only valid after
	 * {@link #compute} has been called on this node).  If the node is not a
	 * leaf node, then children will be non-null and numChildren will be
	 * positive.
	 *
	 * @return {@code true} if this task is a leaf node
	 */
	IsLeaf() bool

	/**
	 * Indicates whether this task is the root node
	 *
	 * @return {@code true} if this task is the root node.
	 */
	IsRoot() bool

	/**
	 * Target leaf size, common to all tasks in a computation
	 *
	 * @return target leaf size.
	 */
	TargetSize() int

	/**
	 * Default target of leaf tasks for parallel decomposition.
	 * To allow load balancing, we over-partition, currently to approximately
	 * four tasks per processor, which enables others to help out
	 * if leaf tasks are uneven or some processors are otherwise busy.
	 *
	 * @return the default target size of leaf tasks
	 */
	GetLeafTarget() int

	/**
	 * Constructs a new node of type T whose parent is the receiver; must call
	 * the TODOTask(T, Spliterator) constructor with the receiver and the
	 * provided Spliterator.
	 *
	 * @param spliterator {@code Spliterator} describing the subtree rooted at
	 *        this node, obtained by splitting the parent {@code Spliterator}
	 * @return newly constructed child node
	 */
	MakeChild(spliterator spliterator.Spliterator) Task

	/**
	 * Computes the result associated with a leaf node.  Will be called by
	 * {@code compute()} and the result passed to @{code setLocalResult()}
	 *
	 * @return the computed result of a leaf node
	 */
	DoLeaf(ctx context.Context) Sink

	/**
	 * Retrieves a result previously stored with {@link #setLocalResult}
	 *
	 * @return local result for this node previously stored with
	 * {@link #setLocalResult}
	 */
	GetLocalResult() Sink

	/**
	 * Associates the result with the task, can be retrieved with
	 * {@link #GetLocalResult}
	 *
	 * @param localResult local result for this node
	 */
	SetLocalResult(localResult Sink)

	/**
	 * Decides whether or not to split a task further or compute it
	 * directly. If computing directly, calls {@code doLeaf} and pass
	 * the result to {@code setRawResult}. Otherwise splits off
	 * subtasks, forking one and continuing as the other.
	 *
	 * <p> The method is structured to conserve resources across a
	 * range of uses.  The loop continues with one of the child tasks
	 * when split, to avoid deep recursion. To cope with spliterators
	 * that may be systematically biased toward left-heavy or
	 * right-heavy splits, we alternate which child is forked versus
	 * continued in the loop.
	 */
	Compute(ctx context.Context)

	/**
	 * {@inheritDoc}
	 *
	 * @implNote
	 * Clears spliterator and children fields.  Overriders MUST call
	 * {@code super.onCompletion} as the last thing they do if they want these
	 * cleared.
	 */
	OnCompletion(caller Task)

	/**
	 * Returns whether this node is a "leftmost" node -- whether the path from
	 * the root to this node involves only traversing leftmost child links.  For
	 * a leaf node, this means it is the first leaf node in the encounter order.
	 *
	 * @return {@code true} if this node is a "leftmost" node
	 */
	IsLeftmostNode() bool

	/**
	 * Arranges to asynchronously execute this task in the pool the
	 * current task is running in, if applicable, or using the {@link
	 * ForkJoinPool#commonPool()} if not {@link #inForkJoinPool}.  While
	 * it is not necessarily enforced, it is a usage error to fork a
	 * task more than once unless it has completed and been
	 * reinitialized.  Subsequent modifications to the state of this
	 * task or any data it operates on are not necessarily
	 * consistently observable by any thread other than the one
	 * executing it unless preceded by a call to {@link #join} or
	 * related methods, or a call to {@link #isDone} returning {@code
	 * true}.
	 *
	 * @return {@code this}, to simplify usage
	 */
	Fork(ctx context.Context)

	/**
	 * Returns the result of the computation when it
	 * {@linkplain #isDone is done}.
	 * This method differs from {@link #get()} in that abnormal
	 * completion results in {@code RuntimeException} or {@code Error},
	 * not {@code ExecutionException}, and that interrupts of the
	 * calling thread do <em>not</em> cause the method to abruptly
	 * return by throwing {@code InterruptedException}.
	 *
	 * @return the computed result
	 */
	Join() Sink

	/**
	 * Commences performing this task, awaits its completion if
	 * necessary, and returns its result, or throws an (unchecked)
	 * {@code RuntimeException} or {@code Error} if the underlying
	 * computation did so.
	 *
	 * @return the computed result
	 */
	Invoke(ctx context.Context) Sink
}