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

Class InstanceExecutionBuilderFactory<INSTANCE,RESULT>

java.lang.Object

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

org.mule.commons.atlantic.execution.builder.factory.InstanceExecutionBuilderFactory<INSTANCE,RESULT>

Type Parameters:

INSTANCE - The type of object over which the execution will be made. This can be an interface.

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

public class InstanceExecutionBuilderFactory<INSTANCE,RESULT>
extends ExecutionBuilderFactory<InstanceExecutionBuilderFactory<INSTANCE,RESULT>,RESULT>

ExecutionBuilderFactory in charge of executing instance methods. 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 method, starting from instance methods of 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 InstanceExecutionBuilderFactory(myInstance).execute(MyInstance::myMethod) .withParam(param1) .withParam(param2); Where myInstance is an instance of the MyInstance class, myMethod is an instance method on it, param1 is the first parameter on myMethod, param2 is the second (and last) parameter on myMethod and MyResult is the returning object of myMethod. This means that that execution is the equivalent of doing: MyResult result = myInstance.myMethod(param1, param2); 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
InstanceExecutionBuilderFactory(INSTANCE instance) Default constructor.

Method Summary

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

InstanceExecutionBuilderFactory

public InstanceExecutionBuilderFactory(INSTANCE instance)

Default constructor. Takes the instance over which the execution will be made.

Parameters:

instance - The instance over which the execution will be made.

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(HendecaConsumer<INSTANCE,A,B,C,D,E,F,G,H,I,J> lambda)

Starts the execution build for a HendecaConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(HendecaFunction<INSTANCE,A,B,C,D,E,F,G,H,I,J,RESULT> lambda)

Starts the execution build for a HendecaFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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 a determined result.

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(HendecaFunction<INSTANCE,A,B,C,D,E,F,G,H,I,J,UNPARSED_RESULT> lambda,
                                                                                                                     Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a HendecaFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(DecaConsumer<INSTANCE,A,B,C,D,E,F,G,H,I> lambda)

Starts the execution build for a DecaConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(DecaFunction<INSTANCE,A,B,C,D,E,F,G,H,I,RESULT> lambda)

Starts the execution build for a DecaFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(DecaFunction<INSTANCE,A,B,C,D,E,F,G,H,I,UNPARSED_RESULT> lambda,
                                                                                                                 Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a DecaFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(NonaConsumer<INSTANCE,A,B,C,D,E,F,G,H> lambda)

Starts the execution build for a NonaConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(NonaFunction<INSTANCE,A,B,C,D,E,F,G,H,RESULT> lambda)

Starts the execution build for a NonaFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(NonaFunction<INSTANCE,A,B,C,D,E,F,G,H,UNPARSED_RESULT> lambda,
                                                                                                             Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a NonaFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(OctaConsumer<INSTANCE,A,B,C,D,E,F,G> lambda)

Starts the execution build for a OctaConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(OctaFunction<INSTANCE,A,B,C,D,E,F,G,RESULT> lambda)

Starts the execution build for a OctaFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(OctaFunction<INSTANCE,A,B,C,D,E,F,G,UNPARSED_RESULT> lambda,
                                                                                                          Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a OctaFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(HeptaConsumer<INSTANCE,A,B,C,D,E,F> lambda)

Starts the execution build for a HeptaConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(HeptaFunction<INSTANCE,A,B,C,D,E,F,RESULT> lambda)

Starts the execution build for a HeptaFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(HeptaFunction<INSTANCE,A,B,C,D,E,F,UNPARSED_RESULT> lambda,
                                                                                                     Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a HeptaFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(HexaConsumer<INSTANCE,A,B,C,D,E> lambda)

Starts the execution build for a HexaConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(HexaFunction<INSTANCE,A,B,C,D,E,RESULT> lambda)

Starts the execution build for a HexaFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(HexaFunction<INSTANCE,A,B,C,D,E,UNPARSED_RESULT> lambda,
                                                                                                  Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a HexaFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(PentaConsumer<INSTANCE,A,B,C,D> lambda)

Starts the execution build for a PentaConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(PentaFunction<INSTANCE,A,B,C,D,RESULT> lambda)

Starts the execution build for a PentaFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(PentaFunction<INSTANCE,A,B,C,D,UNPARSED_RESULT> lambda,
                                                                                              Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a PentaFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(TetraConsumer<INSTANCE,A,B,C> lambda)

Starts the execution build for a TetraConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(TetraFunction<INSTANCE,A,B,C,RESULT> lambda)

Starts the execution build for a TetraFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(TetraFunction<INSTANCE,A,B,C,UNPARSED_RESULT> lambda,
                                                                                        Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a TetraFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(TriConsumer<INSTANCE,A,B> lambda)

Starts the execution build for a TriConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(TriFunction<INSTANCE,A,B,RESULT> lambda)

Starts the execution build for a TriFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(TriFunction<INSTANCE,A,B,UNPARSED_RESULT> lambda,
                                                                                   Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a TriFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(BiConsumer<INSTANCE,A> lambda)

Starts the execution build for a BiConsumer. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(BiFunction<INSTANCE,A,RESULT> lambda)

Starts the execution build for a BiFunction. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(BiFunction<INSTANCE,A,UNPARSED_RESULT> lambda,
                                                                             Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a BiFunction parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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(Consumer<INSTANCE> lambda)

Starts the execution for a Consumer. Have in mind that the only element of the consumer will be the instance on which the method executes.

Parameters:

lambda - The consumer to execute.

execute

public <RESULT> RESULT execute(Function<INSTANCE,RESULT> lambda)

Starts the execution build for a Function. Have in mind that the only element of the consumer will be the instance on which the method executes.

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(Function<INSTANCE,UNPARSED_RESULT> lambda,
                                               Parser<UNPARSED_RESULT,RESULT> resultParser)

Starts the execution build for a Function parsing the result with a Parser. Have in mind that the first element of the consumer will be the instance on which the method executes.

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.