Package lu.kbra.pclib.async

Class NextTask<F,I,O>

java.lang.Object

lu.kbra.pclib.async.NextTask<F,I,O>

public class NextTask<F,I,O>
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
protected static class	NextTask.NextTaskStatus

Field Summary

Fields

Modifier and Type	Field	Description
protected ThrowingConsumer<Throwable,Throwable>	catcher
protected static final int	DONE
protected static final int	ERROR
protected static final ExecutorService	EXECUTOR
protected NextTask<F,F,?>	first
protected static final int	IDLE
protected NextTask<F,O,?>	next
protected static final int	RUNNING
protected final NextTask.NextTaskStatus	sharedState
protected ThrowingFunction<I,O,Throwable>	task

Constructor Summary

Constructors

Modifier	Constructor	Description
protected	NextTask(ThrowingFunction<I,O,Throwable> task)

Method Summary

Modifier and Type	Method	Description
NextTask<F,I,O>	catch_(ThrowingConsumer<Throwable,Throwable> e)
static <O> NextTask<O,O,List<O>>	chain(ThrowingFunction<O,O,Throwable>... tasks)
static <O> NextTask<Void,Void,List<O>>	collect(List<NextTask<Void,?,O>> tasks)
static <O> NextTask<Void,Void,List<O>>	collect(Stream<NextTask<Void,?,O>> stream)
static <O> NextTask<Void,Void,List<O>>	collect(NextTask<Void,?,O>... tasks)
static <O> NextTask<O,O,List<O>>	collector(List<NextTask<Void,?,O>> tasks)	last output + all the new ones
static <O> NextTask<O,O,List<O>>	collector(Stream<NextTask<Void,?,O>> stream)	last output + all the new ones
static <O> NextTask<O,O,List<O>>	collector(NextTask<Void,?,O>... tasks)	last output + all the new ones
static <O> NextTask<Void,Void,List<O>>	collectSuppliers(List<ThrowingSupplier<O,Throwable>> tasks)
static <O> NextTask<Void,Void,List<O>>	collectSuppliers(Stream<ThrowingSupplier<O,Throwable>> stream)
static <O> NextTask<Void,Void,List<O>>	collectSuppliers(ThrowingSupplier<O,Throwable>... tasks)
static <O> NextTask<Void,Void,O>	create(ThrowingFunction<Void,O,Throwable> task)
static NextTask<Void,Void,Void>	create(ThrowingRunnable<Throwable> task)
static <O> NextTask<Void,Void,O>	create(ThrowingSupplier<O,Throwable> task)
static <O> NextTask<Void,Void,O>	empty()
protected <X> Class<?>	getFirstType(NextTask<X,?,?> task)
NextTask.NextTaskStatus	getTaskState()
protected <X> boolean	hasVoidFirstType(NextTask<X,?,?> composed)
NextTask<F,O,O>	orElse(NextTask<Void,?,O> n)
NextTask<F,O,O>	orElse(ThrowingSupplier<O,Throwable> n)
NextTask<F,O,O>	orElse(O n)
NextTask<F,O,O>	orElseThrow(Throwable throw_)
NextTask<F,O,O>	orElseThrow(ThrowingSupplier<Throwable,Throwable> throw_)
static <I, O> NextTask<I,I,List<O>>	parallel(List<NextTask<I,?,O>> tasks)
static <I, O> NextTask<I,I,List<O>>	parallel(Stream<NextTask<I,?,O>> tasks)
static <I, O> NextTask<I,I,List<O>>	parallel(NextTask<I,?,O>... tasks)
protected void	propagateException(Throwable e)
NextTask<F,I,O>	quiet()
O	run()
O	run(F input)
NextTask.NextTaskStatus	runAsync()
NextTask.NextTaskStatus	runAsync(F input)
NextTask.NextTaskStatus	runAsync(F input, ExecutorService exec)
NextTask.NextTaskStatus	runAsync(ExecutorService exec)
O	runThrow()
O	runThrow(F input)
<N> NextTask<F,O,N>	thenApply(ThrowingFunction<O,N,Throwable> nextFunction)
<N> NextTask<F,O,N>	thenCompose(NextTask<O,?,N> nextTask)
<N, X> NextTask<F,O,N>	thenCompose(ThrowingFunction<O,NextTask<X,?,N>,Throwable> nextTaskFunction)
<N, X> NextTask<F,O,N>	thenCompose(ThrowingSupplier<NextTask<X,?,N>,Throwable> nextTaskFunction)
NextTask<F,O,Void>	thenConsume(ThrowingConsumer<O,Throwable> consumer)
NextTask<F,O,O>	thenParallel(ThrowingConsumer<O,Throwable> nextFunction)
NextTask<F,O,Optional<O>>	toOptional()
static <I> NextTask<I,I,Void>	withArg(ThrowingConsumer<I,Throwable> task)
static <I, O> NextTask<I,I,O>	withArg(ThrowingFunction<I,O,Throwable> task)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

EXECUTOR

protected static final ExecutorService EXECUTOR

IDLE

protected static final int IDLE

See Also:

• Constant Field Values

RUNNING

protected static final int RUNNING

See Also:

• Constant Field Values

DONE

protected static final int DONE

See Also:

• Constant Field Values

ERROR

protected static final int ERROR

See Also:

• Constant Field Values

sharedState

protected final NextTask.NextTaskStatus sharedState

first

protected NextTask<F,F,?> first

next

protected NextTask<F,O,?> next

catcher

protected ThrowingConsumer<Throwable,Throwable> catcher

task

protected ThrowingFunction<I,O,Throwable> task

Constructor Details

NextTask

protected NextTask(ThrowingFunction<I,O,Throwable> task)

Method Details

chain

@SafeVarargs
public static <O> NextTask<O,O,List<O>> chain(ThrowingFunction<O,O,Throwable>... tasks)

collect

public static <O> NextTask<Void,Void,List<O>> collect(List<NextTask<Void,?,O>> tasks)

collect

@SafeVarargs
public static <O> NextTask<Void,Void,List<O>> collect(NextTask<Void,?,O>... tasks)

collect

public static <O> NextTask<Void,Void,List<O>> collect(Stream<NextTask<Void,?,O>> stream)

collector

public static <O> NextTask<O,O,List<O>> collector(List<NextTask<Void,?,O>> tasks)

last output + all the new ones

collector

@SafeVarargs
public static <O> NextTask<O,O,List<O>> collector(NextTask<Void,?,O>... tasks)

last output + all the new ones

collector

public static <O> NextTask<O,O,List<O>> collector(Stream<NextTask<Void,?,O>> stream)

last output + all the new ones

collectSuppliers

public static <O> NextTask<Void,Void,List<O>> collectSuppliers(List<ThrowingSupplier<O,Throwable>> tasks)

collectSuppliers

public static <O> NextTask<Void,Void,List<O>> collectSuppliers(Stream<ThrowingSupplier<O,Throwable>> stream)

collectSuppliers

@SafeVarargs
public static <O> NextTask<Void,Void,List<O>> collectSuppliers(ThrowingSupplier<O,Throwable>... tasks)

create

public static <O> NextTask<Void,Void,O> create(ThrowingFunction<Void,O,Throwable> task)

create

public static NextTask<Void,Void,Void> create(ThrowingRunnable<Throwable> task)

create

public static <O> NextTask<Void,Void,O> create(ThrowingSupplier<O,Throwable> task)

empty

public static <O> NextTask<Void,Void,O> empty()

parallel

public static <I,
O> NextTask<I,I,List<O>> parallel(List<NextTask<I,?,O>> tasks)

parallel

@SafeVarargs
public static <I,
O> NextTask<I,I,List<O>> parallel(NextTask<I,?,O>... tasks)

parallel

public static <I,
O> NextTask<I,I,List<O>> parallel(Stream<NextTask<I,?,O>> tasks)

withArg

public static <I> NextTask<I,I,Void> withArg(ThrowingConsumer<I,Throwable> task)

withArg

public static <I,
O> NextTask<I,I,O> withArg(ThrowingFunction<I,O,Throwable> task)

catch_

public NextTask<F,I,O> catch_(ThrowingConsumer<Throwable,Throwable> e)

getTaskState

public NextTask.NextTaskStatus getTaskState()

orElse

public NextTask<F,O,O> orElse(NextTask<Void,?,O> n)

orElse

public NextTask<F,O,O> orElse(O n)

orElse

public NextTask<F,O,O> orElse(ThrowingSupplier<O,Throwable> n)

orElseThrow

public NextTask<F,O,O> orElseThrow(Throwable throw_)

orElseThrow

public NextTask<F,O,O> orElseThrow(ThrowingSupplier<Throwable,Throwable> throw_)

quiet

public NextTask<F,I,O> quiet()

run

public O run()

run

public O run(F input)

runAsync

public NextTask.NextTaskStatus runAsync()

runAsync

public NextTask.NextTaskStatus runAsync(ExecutorService exec)

runAsync

public NextTask.NextTaskStatus runAsync(F input)

runAsync

public NextTask.NextTaskStatus runAsync(F input,
 ExecutorService exec)

runThrow

public O runThrow()
           throws Throwable

Throws:

Throwable

runThrow

public O runThrow(F input)
           throws Throwable

Throws:

Throwable

thenApply

public <N> NextTask<F,O,N> thenApply(ThrowingFunction<O,N,Throwable> nextFunction)

thenCompose

public <N> NextTask<F,O,N> thenCompose(NextTask<O,?,N> nextTask)

thenCompose

public <N,
X> NextTask<F,O,N> thenCompose(ThrowingFunction<O,NextTask<X,?,N>,Throwable> nextTaskFunction)

thenCompose

public <N,
X> NextTask<F,O,N> thenCompose(ThrowingSupplier<NextTask<X,?,N>,Throwable> nextTaskFunction)

thenConsume

public NextTask<F,O,Void> thenConsume(ThrowingConsumer<O,Throwable> consumer)

thenParallel

public NextTask<F,O,O> thenParallel(ThrowingConsumer<O,Throwable> nextFunction)

toOptional

public NextTask<F,O,Optional<O>> toOptional()

getFirstType

protected <X> Class<?> getFirstType(NextTask<X,?,?> task)

hasVoidFirstType

protected <X> boolean hasVoidFirstType(NextTask<X,?,?> composed)

propagateException

protected void propagateException(Throwable e)
                           throws Throwable

Throws:

Throwable