org.mule.connectors.atlantic.commons.builder.execution

Class ExecutionBuilder<T>

java.lang.Object

org.mule.connectors.atlantic.commons.builder.config.ConfigurableBuilder<T,ExecutionBuilder<T>>

org.mule.connectors.atlantic.commons.builder.execution.ExecutionBuilder<T>

public class ExecutionBuilder<T>
extends ConfigurableBuilder<T,ExecutionBuilder<T>>

Constructor Summary

Constructors

Constructor and Description
ExecutionBuilder(T executingObject)

Method Summary

Modifier and Type	Method and Description
<A> MonoParamExecutionBuilder<T,A,Void,Void>	execute(BiConsumer<T,A> executionStrategy)
<A,R> MonoParamExecutionBuilder<T,A,R,R>	execute(BiFunction<T,A,R> executionStrategy)
<A,R,PR> MonoParamExecutionBuilder<T,A,R,PR>	execute(BiFunction<T,A,R> executionStrategy, Function<R,PR> resultParser)
void	execute(Consumer<T> executionStrategy)
<A,B,C,D,E,F,G,H,I> NonaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,Void,Void>	execute(DecaConsumer<T,A,B,C,D,E,F,G,H,I> executionStrategy)
<A,B,C,D,E,F,G,H,I,R> NonaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,R,R>	execute(DecaFunction<T,A,B,C,D,E,F,G,H,I,R> executionStrategy)
<A,B,C,D,E,F,G,H,I,R,PR> NonaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,R,PR>	execute(DecaFunction<T,A,B,C,D,E,F,G,H,I,R> executionStrategy, Function<R,PR> resultParser)
<R> R	execute(Function<T,R> executionStrategy)
<R,PR> PR	execute(Function<T,R> executionStrategy, Function<R,PR> resultParser)
<A,B,C,D,E,F,G,H,I,J> DecaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,J,Void,Void>	execute(HendecaConsumer<T,A,B,C,D,E,F,G,H,I,J> executionStrategy)
<A,B,C,D,E,F,G,H,I,J,R> DecaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,J,R,R>	execute(HendecaFunction<T,A,B,C,D,E,F,G,H,I,J,R> executionStrategy)
<A,B,C,D,E,F,G,H,I,J,R,PR> DecaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,J,R,PR>	execute(HendecaFunction<T,A,B,C,D,E,F,G,H,I,J,R> executionStrategy, Function<R,PR> resultParser)
<A,B,C,D,E,F> HexaParamExecutionBuilder<T,A,B,C,D,E,F,Void,Void>	execute(HeptaConsumer<T,A,B,C,D,E,F> executionStrategy)
<A,B,C,D,E,F,R> HexaParamExecutionBuilder<T,A,B,C,D,E,F,R,R>	execute(HeptaFunction<T,A,B,C,D,E,F,R> executionStrategy)
<A,B,C,D,E,F,R,PR> HexaParamExecutionBuilder<T,A,B,C,D,E,F,R,PR>	execute(HeptaFunction<T,A,B,C,D,E,F,R> executionStrategy, Function<R,PR> resultParser)
<A,B,C,D,E> PentaParamExecutionBuilder<T,A,B,C,D,E,Void,Void>	execute(HexaConsumer<T,A,B,C,D,E> executionStrategy)
<A,B,C,D,E,R> PentaParamExecutionBuilder<T,A,B,C,D,E,R,R>	execute(HexaFunction<T,A,B,C,D,E,R> executionStrategy)
<A,B,C,D,E,R,PR> PentaParamExecutionBuilder<T,A,B,C,D,E,R,PR>	execute(HexaFunction<T,A,B,C,D,E,R> executionStrategy, Function<R,PR> resultParser)
<A,B,C,D,E,F,G,H> OctaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,Void,Void>	execute(NonaConsumer<T,A,B,C,D,E,F,G,H> executionStrategy)
<A,B,C,D,E,F,G,H,R> OctaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,R,R>	execute(NonaFunction<T,A,B,C,D,E,F,G,H,R> executionStrategy)
<A,B,C,D,E,F,G,H,R,PR> OctaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,R,PR>	execute(NonaFunction<T,A,B,C,D,E,F,G,H,R> executionStrategy, Function<R,PR> resultParser)
<A,B,C,D,E,F,G> HeptaParamExecutionBuilder<T,A,B,C,D,E,F,G,Void,Void>	execute(OctaConsumer<T,A,B,C,D,E,F,G> executionStrategy)
<A,B,C,D,E,F,G,R> HeptaParamExecutionBuilder<T,A,B,C,D,E,F,G,R,R>	execute(OctaFunction<T,A,B,C,D,E,F,G,R> executionStrategy)
<A,B,C,D,E,F,G,R,PR> HeptaParamExecutionBuilder<T,A,B,C,D,E,F,G,R,PR>	execute(OctaFunction<T,A,B,C,D,E,F,G,R> executionStrategy, Function<R,PR> resultParser)
<A,B,C,D> TetraParamExecutionBuilder<T,A,B,C,D,Void,Void>	execute(PentaConsumer<T,A,B,C,D> executionStrategy)
<A,B,C,D,R> TetraParamExecutionBuilder<T,A,B,C,D,R,R>	execute(PentaFunction<T,A,B,C,D,R> executionStrategy)
<A,B,C,D,R,PR> TetraParamExecutionBuilder<T,A,B,C,D,R,PR>	execute(PentaFunction<T,A,B,C,D,R> executionStrategy, Function<R,PR> resultParser)
<A,B,C> TriParamExecutionBuilder<T,A,B,C,Void,Void>	execute(TetraConsumer<T,A,B,C> executionStrategy)
<A,B,C,R> TriParamExecutionBuilder<T,A,B,C,R,R>	execute(TetraFunction<T,A,B,C,R> executionStrategy)
<A,B,C,R,PR> TriParamExecutionBuilder<T,A,B,C,R,PR>	execute(TetraFunction<T,A,B,C,R> executionStrategy, Function<R,PR> resultParser)
<A,B> BiParamExecutionBuilder<T,A,B,Void,Void>	execute(TriConsumer<T,A,B> executionStrategy)
<A,B,R> BiParamExecutionBuilder<T,A,B,R,R>	execute(TriFunction<T,A,B,R> executionStrategy)
<A,B,R,PR> BiParamExecutionBuilder<T,A,B,R,PR>	execute(TriFunction<T,A,B,R> executionStrategy, Function<R,PR> resultParser)

Methods inherited from class org.mule.connectors.atlantic.commons.builder.config.ConfigurableBuilder

getConfig, withExceptionHandler, withExceptionHandler, withExecutor, withPreExecutionListener

Methods inherited from class java.lang.Object

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

Constructor Detail

ExecutionBuilder

public ExecutionBuilder(T executingObject)

Method Detail

execute

public <A,B,C,D,E,F,G,H,I,J> DecaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,J,Void,Void> execute(HendecaConsumer<T,A,B,C,D,E,F,G,H,I,J> executionStrategy)

execute

public <A,B,C,D,E,F,G,H,I> NonaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,Void,Void> execute(DecaConsumer<T,A,B,C,D,E,F,G,H,I> executionStrategy)

execute

public <A,B,C,D,E,F,G,H> OctaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,Void,Void> execute(NonaConsumer<T,A,B,C,D,E,F,G,H> executionStrategy)

execute

public <A,B,C,D,E,F,G> HeptaParamExecutionBuilder<T,A,B,C,D,E,F,G,Void,Void> execute(OctaConsumer<T,A,B,C,D,E,F,G> executionStrategy)

execute

public <A,B,C,D,E,F> HexaParamExecutionBuilder<T,A,B,C,D,E,F,Void,Void> execute(HeptaConsumer<T,A,B,C,D,E,F> executionStrategy)

execute

public <A,B,C,D,E> PentaParamExecutionBuilder<T,A,B,C,D,E,Void,Void> execute(HexaConsumer<T,A,B,C,D,E> executionStrategy)

execute

public <A,B,C,D> TetraParamExecutionBuilder<T,A,B,C,D,Void,Void> execute(PentaConsumer<T,A,B,C,D> executionStrategy)

execute

public <A,B,C> TriParamExecutionBuilder<T,A,B,C,Void,Void> execute(TetraConsumer<T,A,B,C> executionStrategy)

execute

public <A,B> BiParamExecutionBuilder<T,A,B,Void,Void> execute(TriConsumer<T,A,B> executionStrategy)

execute

public <A> MonoParamExecutionBuilder<T,A,Void,Void> execute(BiConsumer<T,A> executionStrategy)

execute

public void execute(Consumer<T> executionStrategy)

execute

public <A,B,C,D,E,F,G,H,I,J,R> DecaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,J,R,R> execute(HendecaFunction<T,A,B,C,D,E,F,G,H,I,J,R> executionStrategy)

execute

public <A,B,C,D,E,F,G,H,I,R> NonaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,R,R> execute(DecaFunction<T,A,B,C,D,E,F,G,H,I,R> executionStrategy)

execute

public <A,B,C,D,E,F,G,H,R> OctaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,R,R> execute(NonaFunction<T,A,B,C,D,E,F,G,H,R> executionStrategy)

execute

public <A,B,C,D,E,F,G,R> HeptaParamExecutionBuilder<T,A,B,C,D,E,F,G,R,R> execute(OctaFunction<T,A,B,C,D,E,F,G,R> executionStrategy)

execute

public <A,B,C,D,E,F,R> HexaParamExecutionBuilder<T,A,B,C,D,E,F,R,R> execute(HeptaFunction<T,A,B,C,D,E,F,R> executionStrategy)

execute

public <A,B,C,D,E,R> PentaParamExecutionBuilder<T,A,B,C,D,E,R,R> execute(HexaFunction<T,A,B,C,D,E,R> executionStrategy)

execute

public <A,B,C,D,R> TetraParamExecutionBuilder<T,A,B,C,D,R,R> execute(PentaFunction<T,A,B,C,D,R> executionStrategy)

execute

public <A,B,C,R> TriParamExecutionBuilder<T,A,B,C,R,R> execute(TetraFunction<T,A,B,C,R> executionStrategy)

execute

public <A,B,R> BiParamExecutionBuilder<T,A,B,R,R> execute(TriFunction<T,A,B,R> executionStrategy)

execute

public <A,R> MonoParamExecutionBuilder<T,A,R,R> execute(BiFunction<T,A,R> executionStrategy)

execute

public <R> R execute(Function<T,R> executionStrategy)

execute

public <A,B,C,D,E,F,G,H,I,J,R,PR> DecaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,J,R,PR> execute(HendecaFunction<T,A,B,C,D,E,F,G,H,I,J,R> executionStrategy,
                                                                                                Function<R,PR> resultParser)

execute

public <A,B,C,D,E,F,G,H,I,R,PR> NonaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,I,R,PR> execute(DecaFunction<T,A,B,C,D,E,F,G,H,I,R> executionStrategy,
                                                                                            Function<R,PR> resultParser)

execute

public <A,B,C,D,E,F,G,H,R,PR> OctaParamExecutionBuilder<T,A,B,C,D,E,F,G,H,R,PR> execute(NonaFunction<T,A,B,C,D,E,F,G,H,R> executionStrategy,
                                                                                        Function<R,PR> resultParser)

execute

public <A,B,C,D,E,F,G,R,PR> HeptaParamExecutionBuilder<T,A,B,C,D,E,F,G,R,PR> execute(OctaFunction<T,A,B,C,D,E,F,G,R> executionStrategy,
                                                                                     Function<R,PR> resultParser)

execute

public <A,B,C,D,E,F,R,PR> HexaParamExecutionBuilder<T,A,B,C,D,E,F,R,PR> execute(HeptaFunction<T,A,B,C,D,E,F,R> executionStrategy,
                                                                                Function<R,PR> resultParser)

execute

public <A,B,C,D,E,R,PR> PentaParamExecutionBuilder<T,A,B,C,D,E,R,PR> execute(HexaFunction<T,A,B,C,D,E,R> executionStrategy,
                                                                             Function<R,PR> resultParser)

execute

public <A,B,C,D,R,PR> TetraParamExecutionBuilder<T,A,B,C,D,R,PR> execute(PentaFunction<T,A,B,C,D,R> executionStrategy,
                                                                         Function<R,PR> resultParser)

execute

public <A,B,C,R,PR> TriParamExecutionBuilder<T,A,B,C,R,PR> execute(TetraFunction<T,A,B,C,R> executionStrategy,
                                                                   Function<R,PR> resultParser)

execute

public <A,B,R,PR> BiParamExecutionBuilder<T,A,B,R,PR> execute(TriFunction<T,A,B,R> executionStrategy,
                                                              Function<R,PR> resultParser)

execute

public <A,R,PR> MonoParamExecutionBuilder<T,A,R,PR> execute(BiFunction<T,A,R> executionStrategy,
                                                            Function<R,PR> resultParser)

execute

public <R,PR> PR execute(Function<T,R> executionStrategy,
                         Function<R,PR> resultParser)