org.mule.commons.atlantic.execution.builder.factory

Class StaticExecutionBuilderFactory<RESULT>

java.lang.Object

org.mule.commons.atlantic.execution.builder.factory.ExecutionBuilderFactory<StaticExecutionBuilderFactory<RESULT>,RESULT>

org.mule.commons.atlantic.execution.builder.factory.StaticExecutionBuilderFactory<RESULT>

Type Parameters:

RESULT - The type of result returned by the execution to build.

public class StaticExecutionBuilderFactory<RESULT>
extends ExecutionBuilderFactory<StaticExecutionBuilderFactory<RESULT>,RESULT>

ExecutionBuilderFactory in charge of executing static methods and constructors. This class contains a set of configuration methods an a series overloaded methods called execute. Each of these execute methods allow for the execution of a different type of static method or constructor, starting from no parameters to up to 10 parameters on it. The configuration methods allow to set a list of pre execution listeners, another list of post execution listeners, a list of exception handlers and the handler for the thread execution. The execution for such methods will follow the following code: MyResult result = new StaticExecutionBuilderFactory().execute(MyClass::myStaticMethod) .withParam(param1) .withParam(param2); Where myStaticMethod is a static method on the MyClass class, param1 is the first parameter on myStaticMethod, param2 is the second (and last) parameter on myStaticMethod and MyResult is the returning object of myStaticMethod. This means that that execution is the equivalent of doing: MyResult result = MyClass.myStaticMethod.myMethod(param1, param2); Optionally, an additional execution for this executor can follow the following code: MyClass newMyClassInstance = new StaticExecutionBuilderFactory().execute(MyClass::new) .withParam(param1) .withParam(param2); Where newMyClassInstance is an instance of the MyClass class, param1 is the first parameter on the constructor, param2 is the second (and last) parameter on the constructor. The advantage of doing this in this way is all the wrappers and listeners that we can add to the execution.

Constructor Summary

Constructors

Constructor and Description
StaticExecutionBuilderFactory()

Method Summary

Modifier and Type	Method and Description
<A,B> BiFunctionExecutionBuilder<A,B,Void>	execute(BiConsumer<A,B> lambda) Starts the execution build for a BiConsumer.
<A,B,RESULT> BiFunctionExecutionBuilder<A,B,RESULT>	execute(BiFunction<A,B,RESULT> lambda) Starts the execution build for a BiFunction.
<A,B,UNPARSED_RESULT,RESULT> BiFunctionExecutionBuilder<A,B,RESULT>	execute(BiFunction<A,B,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a BiFunction parsing the result with a Parser.
<A> FunctionExecutionBuilder<A,Void>	execute(Consumer<A> lambda) Starts the execution build for a Consumer.
<A,B,C,D,E,F,G,H,I,J> DecaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,J,Void>	execute(DecaConsumer<A,B,C,D,E,F,G,H,I,J> lambda) Starts the execution build for a DecaConsumer.
<A,B,C,D,E,F,G,H,I,J,RESULT> DecaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,J,RESULT>	execute(DecaFunction<A,B,C,D,E,F,G,H,I,J,RESULT> lambda) Starts the execution build for a DecaFunction.
<A,B,C,D,E,F,G,H,I,J,UNPARSED_RESULT,RESULT> DecaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,J,RESULT>	execute(DecaFunction<A,B,C,D,E,F,G,H,I,J,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a DecaFunction parsing the result with a Parser.
<A,RESULT> FunctionExecutionBuilder<A,RESULT>	execute(Function<A,RESULT> lambda) Starts the execution build for a Function.
<A,UNPARSED_RESULT,RESULT> FunctionExecutionBuilder<A,RESULT>	execute(Function<A,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a Function parsing the result with a Parser.
<A,B,C,D,E,F,G> HeptaFunctionExecutionBuilder<A,B,C,D,E,F,G,Void>	execute(HeptaConsumer<A,B,C,D,E,F,G> lambda) Starts the execution build for a HeptaConsumer.
<A,B,C,D,E,F,G,RESULT> HeptaFunctionExecutionBuilder<A,B,C,D,E,F,G,RESULT>	execute(HeptaFunction<A,B,C,D,E,F,G,RESULT> lambda) Starts the execution build for a HeptaFunction.
<A,B,C,D,E,F,G,UNPARSED_RESULT,RESULT> HeptaFunctionExecutionBuilder<A,B,C,D,E,F,G,RESULT>	execute(HeptaFunction<A,B,C,D,E,F,G,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a HeptaFunction parsing the result with a Parser.
<A,B,C,D,E,F> HexaFunctionExecutionBuilder<A,B,C,D,E,F,Void>	execute(HexaConsumer<A,B,C,D,E,F> lambda) Starts the execution build for a HexaConsumer.
<A,B,C,D,E,F,RESULT> HexaFunctionExecutionBuilder<A,B,C,D,E,F,RESULT>	execute(HexaFunction<A,B,C,D,E,F,RESULT> lambda) Starts the execution build for a HexaFunction.
<A,B,C,D,E,F,UNPARSED_RESULT,RESULT> HexaFunctionExecutionBuilder<A,B,C,D,E,F,RESULT>	execute(HexaFunction<A,B,C,D,E,F,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a HexaFunction parsing the result with a Parser.
<A,B,C,D,E,F,G,H,I> NonaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,Void>	execute(NonaConsumer<A,B,C,D,E,F,G,H,I> lambda) Starts the execution build for a NonaConsumer.
<A,B,C,D,E,F,G,H,I,RESULT> NonaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,RESULT>	execute(NonaFunction<A,B,C,D,E,F,G,H,I,RESULT> lambda) Starts the execution build for a NonaFunction.
<A,B,C,D,E,F,G,H,I,UNPARSED_RESULT,RESULT> NonaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,RESULT>	execute(NonaFunction<A,B,C,D,E,F,G,H,I,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a NonaFunction parsing the result with a Parser.
<A,B,C,D,E,F,G,H> OctaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,Void>	execute(OctaConsumer<A,B,C,D,E,F,G,H> lambda) Starts the execution build for a OctaConsumer.
<A,B,C,D,E,F,G,H,RESULT> OctaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,RESULT>	execute(OctaFunction<A,B,C,D,E,F,G,H,RESULT> lambda) Starts the execution build for a OctaFunction.
<A,B,C,D,E,F,G,H,UNPARSED_RESULT,RESULT> OctaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,RESULT>	execute(OctaFunction<A,B,C,D,E,F,G,H,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a OctaFunction parsing the result with a Parser.
<A,B,C,D,E> PentaFunctionExecutionBuilder<A,B,C,D,E,Void>	execute(PentaConsumer<A,B,C,D,E> lambda) Starts the execution build for a PentaConsumer.
<A,B,C,D,E,RESULT> PentaFunctionExecutionBuilder<A,B,C,D,E,RESULT>	execute(PentaFunction<A,B,C,D,E,RESULT> lambda) Starts the execution build for a PentaFunction.
<A,B,C,D,E,UNPARSED_RESULT,RESULT> PentaFunctionExecutionBuilder<A,B,C,D,E,RESULT>	execute(PentaFunction<A,B,C,D,E,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a PentaFunction parsing the result with a Parser.
void	execute(Runnable lambda) Starts the execution build for a Runnable.
<RESULT> RESULT	execute(Supplier<RESULT> lambda) Starts the execution build for a Supplier.
<UNPARSED_RESULT,RESULT> RESULT	execute(Supplier<UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a Supplier parsing the result with a Parser.
<A,B,C,D> TetraFunctionExecutionBuilder<A,B,C,D,Void>	execute(TetraConsumer<A,B,C,D> lambda) Starts the execution build for a TetraConsumer.
<A,B,C,D,RESULT> TetraFunctionExecutionBuilder<A,B,C,D,RESULT>	execute(TetraFunction<A,B,C,D,RESULT> lambda) Starts the execution build for a TetraFunction.
<A,B,C,D,UNPARSED_RESULT,RESULT> TetraFunctionExecutionBuilder<A,B,C,D,RESULT>	execute(TetraFunction<A,B,C,D,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a TetraFunction parsing the result with a Parser.
<A,B,C> TriFunctionExecutionBuilder<A,B,C,Void>	execute(TriConsumer<A,B,C> lambda) Starts the execution build for a TriConsumer.
<A,B,C,RESULT> TriFunctionExecutionBuilder<A,B,C,RESULT>	execute(TriFunction<A,B,C,RESULT> lambda) Starts the execution build for a TriFunction.
<A,B,C,UNPARSED_RESULT,RESULT> TriFunctionExecutionBuilder<A,B,C,RESULT>	execute(TriFunction<A,B,C,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser) Starts the execution build for a TriFunction parsing the result with a Parser.

Methods inherited from class org.mule.commons.atlantic.execution.builder.factory.ExecutionBuilderFactory

build, withDefaultExceptionHandler, withDefaultExceptionHandler, withExceptionHandler, withExceptionHandler, withExecutor, withIgnoredExceptionType, withPostExecutionListener, withPostExecutionListener, withPreExecutionListener, withPreExecutionListener

Methods inherited from class java.lang.Object

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

Constructor Detail

StaticExecutionBuilderFactory

public StaticExecutionBuilderFactory()

Method Detail

execute

public <A,B,C,D,E,F,G,H,I,J> DecaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,J,Void> execute(DecaConsumer<A,B,C,D,E,F,G,H,I,J> lambda)

Starts the execution build for a DecaConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

I - The ninth parameter.

J - The tenth parameter.

Parameters:

lambda - The consumer to execute.

Returns:

DecaFunctionExecutionBuilder The builder for a function that receives 10 parameters and returns Void.

execute

public <A,B,C,D,E,F,G,H,I,J,RESULT> DecaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,J,RESULT> execute(DecaFunction<A,B,C,D,E,F,G,H,I,J,RESULT> lambda)

Starts the execution build for a DecaFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

I - The ninth parameter.

J - The tenth parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

DecaFunctionExecutionBuilder The builder for a function that receives 10 parameters and returns Void.

execute

public <A,B,C,D,E,F,G,H,I,J,UNPARSED_RESULT,RESULT> DecaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,J,RESULT> execute(DecaFunction<A,B,C,D,E,F,G,H,I,J,UNPARSED_RESULT> lambda,
                                                                                                                     Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a DecaFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

I - The ninth parameter.

J - The tenth parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

DecaFunctionExecutionBuilder The builder for a function that receives 10 parameters and returns a determined result.

execute

public <A,B,C,D,E,F,G,H,I> NonaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,Void> execute(NonaConsumer<A,B,C,D,E,F,G,H,I> lambda)

Starts the execution build for a NonaConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

I - The ninth parameter.

Parameters:

lambda - The consumer to execute.

Returns:

NonaFunctionExecutionBuilder The builder for a function that receives 9 parameters and returns Void.

execute

public <A,B,C,D,E,F,G,H,I,RESULT> NonaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,RESULT> execute(NonaFunction<A,B,C,D,E,F,G,H,I,RESULT> lambda)

Starts the execution build for a NonaFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

I - The ninth parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

NonaFunctionExecutionBuilder The builder for a function that receives 9 parameters and returns a determined result.

execute

public <A,B,C,D,E,F,G,H,I,UNPARSED_RESULT,RESULT> NonaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,I,RESULT> execute(NonaFunction<A,B,C,D,E,F,G,H,I,UNPARSED_RESULT> lambda,
                                                                                                                 Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a NonaFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

I - The ninth parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

NonaFunctionExecutionBuilder The builder for a function that receives 9 parameters and returns a determined result.

execute

public <A,B,C,D,E,F,G,H> OctaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,Void> execute(OctaConsumer<A,B,C,D,E,F,G,H> lambda)

Starts the execution build for a OctaConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

Parameters:

lambda - The consumer to execute.

Returns:

OctaFunctionExecutionBuilder The builder for a function that receives 8 parameters and returns Void.

execute

public <A,B,C,D,E,F,G,H,RESULT> OctaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,RESULT> execute(OctaFunction<A,B,C,D,E,F,G,H,RESULT> lambda)

Starts the execution build for a OctaFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

OctaFunctionExecutionBuilder The builder for a function that receives 8 parameters and returns a determined result.

execute

public <A,B,C,D,E,F,G,H,UNPARSED_RESULT,RESULT> OctaFunctionExecutionBuilder<A,B,C,D,E,F,G,H,RESULT> execute(OctaFunction<A,B,C,D,E,F,G,H,UNPARSED_RESULT> lambda,
                                                                                                             Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a OctaFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

H - The eight parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

OctaFunctionExecutionBuilder The builder for a function that receives 8 parameters and returns a determined result.

execute

public <A,B,C,D,E,F,G> HeptaFunctionExecutionBuilder<A,B,C,D,E,F,G,Void> execute(HeptaConsumer<A,B,C,D,E,F,G> lambda)

Starts the execution build for a HeptaConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

Parameters:

lambda - The consumer to execute.

Returns:

HeptaFunctionExecutionBuilder The builder for a function that receives 7 parameters and returns Void.

execute

public <A,B,C,D,E,F,G,RESULT> HeptaFunctionExecutionBuilder<A,B,C,D,E,F,G,RESULT> execute(HeptaFunction<A,B,C,D,E,F,G,RESULT> lambda)

Starts the execution build for a HeptaFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

HeptaFunctionExecutionBuilder The builder for a function that receives 7 parameters and returns a determined result.

execute

public <A,B,C,D,E,F,G,UNPARSED_RESULT,RESULT> HeptaFunctionExecutionBuilder<A,B,C,D,E,F,G,RESULT> execute(HeptaFunction<A,B,C,D,E,F,G,UNPARSED_RESULT> lambda,
                                                                                                          Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a HeptaFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

G - The seventh parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

HeptaFunctionExecutionBuilder The builder for a function that receives 7 parameters and returns a determined result.

execute

public <A,B,C,D,E,F> HexaFunctionExecutionBuilder<A,B,C,D,E,F,Void> execute(HexaConsumer<A,B,C,D,E,F> lambda)

Starts the execution build for a HexaConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

Parameters:

lambda - The consumer to execute.

Returns:

HexaFunctionExecutionBuilder The builder for a function that receives 6 parameters and returns Void.

execute

public <A,B,C,D,E,F,RESULT> HexaFunctionExecutionBuilder<A,B,C,D,E,F,RESULT> execute(HexaFunction<A,B,C,D,E,F,RESULT> lambda)

Starts the execution build for a HexaFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

HexaFunctionExecutionBuilder The builder for a function that receives 6 parameters and returns a determined result.

execute

public <A,B,C,D,E,F,UNPARSED_RESULT,RESULT> HexaFunctionExecutionBuilder<A,B,C,D,E,F,RESULT> execute(HexaFunction<A,B,C,D,E,F,UNPARSED_RESULT> lambda,
                                                                                                     Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a HexaFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

F - The sixth parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

HexaFunctionExecutionBuilder The builder for a function that receives 6 parameters and returns a determined result.

execute

public <A,B,C,D,E> PentaFunctionExecutionBuilder<A,B,C,D,E,Void> execute(PentaConsumer<A,B,C,D,E> lambda)

Starts the execution build for a PentaConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

Parameters:

lambda - The consumer to execute.

Returns:

PentaFunctionExecutionBuilder The builder for a function that receives 5 parameters and returns Void.

execute

public <A,B,C,D,E,RESULT> PentaFunctionExecutionBuilder<A,B,C,D,E,RESULT> execute(PentaFunction<A,B,C,D,E,RESULT> lambda)

Starts the execution build for a PentaFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

PentaFunctionExecutionBuilder The builder for a function that receives 5 parameters and returns a determined result.

execute

public <A,B,C,D,E,UNPARSED_RESULT,RESULT> PentaFunctionExecutionBuilder<A,B,C,D,E,RESULT> execute(PentaFunction<A,B,C,D,E,UNPARSED_RESULT> lambda,
                                                                                                  Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a PentaFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

E - The fifth parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

PentaFunctionExecutionBuilder The builder for a function that receives 5 parameters and returns a determined result.

execute

public <A,B,C,D> TetraFunctionExecutionBuilder<A,B,C,D,Void> execute(TetraConsumer<A,B,C,D> lambda)

Starts the execution build for a TetraConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

Parameters:

lambda - The consumer to execute.

Returns:

TetraFunctionExecutionBuilder The builder for a function that receives 4 parameters and returns Void.

execute

public <A,B,C,D,RESULT> TetraFunctionExecutionBuilder<A,B,C,D,RESULT> execute(TetraFunction<A,B,C,D,RESULT> lambda)

Starts the execution build for a TetraFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

TetraFunctionExecutionBuilder The builder for a function that receives 4 parameters and returns a determined result.

execute

public <A,B,C,D,UNPARSED_RESULT,RESULT> TetraFunctionExecutionBuilder<A,B,C,D,RESULT> execute(TetraFunction<A,B,C,D,UNPARSED_RESULT> lambda,
                                                                                              Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a TetraFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

D - The fourth parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

TetraFunctionExecutionBuilder The builder for a function that receives 4 parameters and returns a determined result.

execute

public <A,B,C> TriFunctionExecutionBuilder<A,B,C,Void> execute(TriConsumer<A,B,C> lambda)

Starts the execution build for a TriConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

Parameters:

lambda - The consumer to execute.

Returns:

TriFunctionExecutionBuilder The builder for a function that receives 3 parameters and returns Void.

execute

public <A,B,C,RESULT> TriFunctionExecutionBuilder<A,B,C,RESULT> execute(TriFunction<A,B,C,RESULT> lambda)

Starts the execution build for a TriFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

TriFunctionExecutionBuilder The builder for a function that receives 3 parameters and returns a determined result.

execute

public <A,B,C,UNPARSED_RESULT,RESULT> TriFunctionExecutionBuilder<A,B,C,RESULT> execute(TriFunction<A,B,C,UNPARSED_RESULT> lambda,
                                                                                        Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a TriFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

C - The third parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

TriFunctionExecutionBuilder The builder for a function that receives 3 parameters and returns a determined result.

execute

public <A,B> BiFunctionExecutionBuilder<A,B,Void> execute(BiConsumer<A,B> lambda)

Starts the execution build for a BiConsumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

Parameters:

lambda - The consumer to execute.

Returns:

BiFunctionExecutionBuilder The builder for a function that receives 2 parameters and returns Void.

execute

public <A,B,RESULT> BiFunctionExecutionBuilder<A,B,RESULT> execute(BiFunction<A,B,RESULT> lambda)

Starts the execution build for a BiFunction. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

BiFunctionExecutionBuilder The builder for a function that receives 2 parameters and returns a determined result.

execute

public <A,B,UNPARSED_RESULT,RESULT> BiFunctionExecutionBuilder<A,B,RESULT> execute(BiFunction<A,B,UNPARSED_RESULT> lambda,
                                                                                   Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a BiFunction parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

B - The second parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

BiFunctionExecutionBuilder The builder for a function that receives 2 parameters and returns a determined result.

execute

public <A> FunctionExecutionBuilder<A,Void> execute(Consumer<A> lambda)

Starts the execution build for a Consumer. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

Parameters:

lambda - The consumer to execute.

Returns:

FunctionExecutionBuilder The builder for a function that receives 1 parameter and returns Void.

execute

public <A,RESULT> FunctionExecutionBuilder<A,RESULT> execute(Function<A,RESULT> lambda)

Starts the execution build for a Function. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

FunctionExecutionBuilder The builder for a function that receives 1 parameter and returns a determined result.

execute

public <A,UNPARSED_RESULT,RESULT> FunctionExecutionBuilder<A,RESULT> execute(Function<A,UNPARSED_RESULT> lambda,
                                                                             Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a Function parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

A - The first parameter.

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

FunctionExecutionBuilder The builder for a function that receives 1 parameter and returns a determined result.

execute

public void execute(Runnable lambda)

Starts the execution build for a Runnable. This consumer can be either a static method or a constructor.

Parameters:

lambda - The consumer to execute.

execute

public <RESULT> RESULT execute(Supplier<RESULT> lambda)

Starts the execution build for a Supplier. This consumer can be either a static method or a constructor.

Type Parameters:

RESULT - The expected result of the execution.

Parameters:

lambda - The consumer to execute.

Returns:

RESULT The result of the execution.

execute

public <UNPARSED_RESULT,RESULT> RESULT execute(Supplier<UNPARSED_RESULT> lambda,
                                               Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a Supplier parsing the result with a Parser. This consumer can be either a static method or a constructor.

Type Parameters:

RESULT - The expected result of the parsed execution.

UNPARSED_RESULT - The result of the lambda.

Parameters:

lambda - The consumer to execute.

resultParser - The instance of Parser that will convert from the result of the function to the expected result.

Returns:

RESULT The result of the execution.