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>
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 and Description |
|---|
InstanceExecutionBuilderFactory(INSTANCE instance)
Default constructor.
|
| 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> |
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> |
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> |
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> |
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> |
execute(Function<INSTANCE,UNPARSED_RESULT> lambda,
Parser<UNPARSED_RESULT,RESULT> resultParser)
|
<A,B,C,D,E,F,G,H,I,J> |
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> |
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> |
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> |
execute(HeptaConsumer<INSTANCE,A,B,C,D,E,F> lambda)
Starts the execution build for a
HeptaConsumer. |
<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> |
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> |
execute(HexaConsumer<INSTANCE,A,B,C,D,E> lambda)
Starts the execution build for a
HexaConsumer. |
<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> |
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> |
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> |
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> |
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> |
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> |
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> |
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> |
execute(PentaFunction<INSTANCE,A,B,C,D,RESULT> lambda)
Starts the execution build for a
PentaFunction. |
<A,B,C,D,UNPARSED_RESULT,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> |
execute(TetraFunction<INSTANCE,A,B,C,RESULT> lambda)
Starts the execution build for a
TetraFunction. |
<A,B,C,UNPARSED_RESULT,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> |
execute(TriFunction<INSTANCE,A,B,RESULT> lambda)
Starts the execution build for a
TriFunction. |
<A,B,UNPARSED_RESULT,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. |
build, withExceptionHandler, withExceptionHandler, withExecutor, withIgnoredExceptionType, withPostExecutionListener, withPostExecutionListener, withPreExecutionListener, withPreExecutionListenerpublic InstanceExecutionBuilderFactory(INSTANCE instance)
instance - The instance over which the execution will be made.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)
HendecaConsumer. Have in mind that the first element of the consumer
will be the instance on which the method executes.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.lambda - The consumer to 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)
HendecaFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.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.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.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)
DecaConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.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.lambda - The consumer to 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)
DecaFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.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.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.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)
NonaConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.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.lambda - The consumer to 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)
NonaFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.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.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.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)
OctaConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.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.lambda - The consumer to 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)
OctaFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.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.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.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)
HeptaConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.A - The first parameter.B - The second parameter.C - The third parameter.D - The fourth parameter.E - The fifth parameter.F - The sixth parameter.lambda - The consumer to 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)
HeptaFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.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.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.public <A,B,C,D,E> PentaFunctionExecutionBuilder<A,B,C,D,E,Void> execute(HexaConsumer<INSTANCE,A,B,C,D,E> lambda)
HexaConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.A - The first parameter.B - The second parameter.C - The third parameter.D - The fourth parameter.E - The fifth parameter.lambda - The consumer to 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)
HexaFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.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.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.public <A,B,C,D> TetraFunctionExecutionBuilder<A,B,C,D,Void> execute(PentaConsumer<INSTANCE,A,B,C,D> lambda)
PentaConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.A - The first parameter.B - The second parameter.C - The third parameter.D - The fourth parameter.lambda - The consumer to execute.public <A,B,C,D,RESULT> TetraFunctionExecutionBuilder<A,B,C,D,RESULT> execute(PentaFunction<INSTANCE,A,B,C,D,RESULT> lambda)
PentaFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.A - The first parameter.B - The second parameter.C - The third parameter.D - The fourth parameter.RESULT - The expected result of the execution.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.public <A,B,C> TriFunctionExecutionBuilder<A,B,C,Void> execute(TetraConsumer<INSTANCE,A,B,C> lambda)
TetraConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.A - The first parameter.B - The second parameter.C - The third parameter.lambda - The consumer to execute.public <A,B,C,RESULT> TriFunctionExecutionBuilder<A,B,C,RESULT> execute(TetraFunction<INSTANCE,A,B,C,RESULT> lambda)
TetraFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.A - The first parameter.B - The second parameter.C - The third parameter.RESULT - The expected result of the execution.lambda - The consumer to 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)
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.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.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.public <A,B> BiFunctionExecutionBuilder<A,B,Void> execute(TriConsumer<INSTANCE,A,B> lambda)
TriConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.A - The first parameter.B - The second parameter.lambda - The consumer to execute.public <A,B,RESULT> BiFunctionExecutionBuilder<A,B,RESULT> execute(TriFunction<INSTANCE,A,B,RESULT> lambda)
TriFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.A - The first parameter.B - The second parameter.RESULT - The expected result of the execution.lambda - The consumer to execute.public <A,B,UNPARSED_RESULT,RESULT> BiFunctionExecutionBuilder<A,B,RESULT> execute(TriFunction<INSTANCE,A,B,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser)
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.A - The first parameter.B - The second parameter.RESULT - The expected result of the parsed execution.UNPARSED_RESULT - The result of the lambda.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.public <A> FunctionExecutionBuilder<A,Void> execute(BiConsumer<INSTANCE,A> lambda)
BiConsumer. Have in mind that the first element of the consumer will
be the instance on which the method executes.A - The first parameter.lambda - The consumer to execute.public <A,RESULT> FunctionExecutionBuilder<A,RESULT> execute(BiFunction<INSTANCE,A,RESULT> lambda)
BiFunction. Have in mind that the first element of the consumer
will be the instance on which the method executes.A - The first parameter.RESULT - The expected result of the execution.lambda - The consumer to execute.public <A,UNPARSED_RESULT,RESULT> FunctionExecutionBuilder<A,RESULT> execute(BiFunction<INSTANCE,A,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser)
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.A - The first parameter.RESULT - The expected result of the parsed execution.UNPARSED_RESULT - The result of the lambda.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.public void execute(Consumer<INSTANCE> lambda)
Consumer. Have in mind that the only element of the consumer will be the
instance on which the method executes.lambda - The consumer to execute.public <RESULT> RESULT execute(Function<INSTANCE,RESULT> lambda)
Function. Have in mind that the only element of the consumer will be the
instance on which the method executes.RESULT - The expected result of the execution.lambda - The consumer to execute.public <UNPARSED_RESULT,RESULT> RESULT execute(Function<INSTANCE,UNPARSED_RESULT> lambda, Parser<UNPARSED_RESULT,RESULT> resultParser)
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.RESULT - The expected result of the parsed execution.UNPARSED_RESULT - The result of the lambda.lambda - The consumer to execute.resultParser - The instance of Parser that will convert from the result of the function to the
expected result.Copyright © 2018. All rights reserved.