brainslug.flow.builder

Class FlowBuilderSupport

java.lang.Object

brainslug.flow.builder.FlowBuilderSupport

Direct Known Subclasses:

FlowBuilder

public class FlowBuilderSupport
extends Object

Field Summary

Fields

Modifier and Type	Field and Description
protected FlowDefinition	definition
protected ServiceCallInvocationSupport	serviceCallInvocation

Constructor Summary

Constructors

Constructor and Description
FlowBuilderSupport()

Method Summary

Modifier and Type	Method and Description
FlowPathDefinition	after(Identifier id) create a flow path for execution after of the node id
GoalDefinition	check(Identifier id, PredicateDefinition goalPredicate)
<T> Expression<T>	constant(T constantValue)
EqualDefinition<Expression,Expression<Object>>	eq(Expression actual, Object expected)
EventDefinition	event(Identifier id)
StartTimerDefinition	every(int interval, TimeUnit intervalUnit) creates a start timer with given interval and unit
<T> Expression	expression(T expression)
GoalDefinition	goal(Identifier id) create a goal definition with the given id.
Identifier	id(Enum id)
Identifier	id(String id)
TrueDefinition<Expression>	isTrue(Expression actual)
FlowPathDefinition	join(Identifier joinId, Identifier... ids) create a flow path joining the execution after the given nodes by introducing a new merge join to which the nodes connect.
FlowPathDefinition	merge(Identifier mergeId, Identifier... ids) create a flow path merging the execution after the given nodes by introducing a new merge node to which the nodes connect.
InvokeDefinition	method(Class<?> clazz)
CallDefinition	method(Object returnValueOfProxyInvocation)
FlowPathDefinition	on(Identifier id) create a flow path for execution after of the given event id
<T extends Predicate> PredicateDefinition<T>	predicate(T predicate)
Property	property(Identifier id)
<T> T	property(Identifier id, Class<T> clazz)
PredicateBuilder<CallDefinition>	resultOf(CallDefinition methodCall)
<T> T	service(Class<T> clazz) create a service proxy to be user for type-safe call definitions.
FlowPathDefinition	start(AbstractEventDefinition event)
FlowPathDefinition	start(AbstractEventDefinition event, StartTimerDefinition startTimerDefinition) create a start event with the given event, which will be started every interval with the duration given in the timer definition.
FlowPathDefinition	start(AbstractTaskDefinition task) define task as first node in the flow
FlowPathDefinition	start(Identifier startId) create a start event with the given id.
FlowPathDefinition	start(Identifier id, AbstractTaskDefinition task, StartTimerDefinition startTimerDefinition)
FlowPathDefinition	start(Identifier startId, StartTimerDefinition startTimerDefinition) create a start event with the given id, which will be started every interval with the duration given in the timer definition.
protected AbstractEventDefinition	startEvent(AbstractEventDefinition event)
protected AbstractEventDefinition	startTimerEvent(AbstractEventDefinition event, StartTimerDefinition startTimerDefinition)
TaskDefinition	task(Identifier id)
TaskDefinition	task(Identifier id, Task callee) create a task definition with the given task to be executed Example:
<T> T	val(Expression<T> expression) add a parameter to the invocation arguments of a proxy method call definition.
FlowBuilderSupport	withDefinition(FlowDefinition definition)

Methods inherited from class java.lang.Object

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

Field Detail

definition

protected FlowDefinition definition

serviceCallInvocation

protected ServiceCallInvocationSupport serviceCallInvocation

Constructor Detail

FlowBuilderSupport

public FlowBuilderSupport()

Method Detail

withDefinition

public FlowBuilderSupport withDefinition(FlowDefinition definition)

id

public Identifier id(Enum id)

id

public Identifier id(String id)

every

public StartTimerDefinition every(int interval,
                                  TimeUnit intervalUnit)

creates a start timer with given interval and unit

Parameters:

interval - the interval

intervalUnit - the unit

Returns:

a start timer to be used for a start event definition

start

public FlowPathDefinition start(Identifier startId)

create a start event with the given id.

Parameters:

startId - the start event id

Returns:

the flow path starting with this event

start

public FlowPathDefinition start(Identifier startId,
                                StartTimerDefinition startTimerDefinition)

create a start event with the given id, which will be started every interval with the duration given in the timer definition.

Parameters:

startId - the start event id

startTimerDefinition - the timer definition defining the interval

Returns:

the flow path starting with this event

start

public FlowPathDefinition start(AbstractEventDefinition event)

start

public FlowPathDefinition start(AbstractEventDefinition event,
                                StartTimerDefinition startTimerDefinition)

create a start event with the given event, which will be started every interval with the duration given in the timer definition.

Parameters:

event - the start event id

startTimerDefinition - the timer definition defining the interval

Returns:

the flow path starting with this event

startEvent

protected AbstractEventDefinition startEvent(AbstractEventDefinition event)

startTimerEvent

protected AbstractEventDefinition startTimerEvent(AbstractEventDefinition event,
                                                  StartTimerDefinition startTimerDefinition)

start

public FlowPathDefinition start(AbstractTaskDefinition task)

define task as first node in the flow

Parameters:

task - the task

Returns:

the flow path starting with this task

start

public FlowPathDefinition start(Identifier id,
                                AbstractTaskDefinition task,
                                StartTimerDefinition startTimerDefinition)

after

public FlowPathDefinition after(Identifier id)

create a flow path for execution after of the node id

Parameters:

id - of the node to continue after

Returns:

the flow after the given node

on

public FlowPathDefinition on(Identifier id)

create a flow path for execution after of the given event id

Parameters:

id - of the event to continue after

Returns:

the flow after the given event

merge

public FlowPathDefinition merge(Identifier mergeId,
                                Identifier... ids)

create a flow path merging the execution after the given nodes by introducing a new merge node to which the nodes connect. execution will continue for every token that triggers this merge node. Example:

  {@literal @}Override public void define() {
      start(event(id(START)))
      .choice(id(CHOICE))
      .when(eq(constant(x) ,"test")).execute(task(id(TASK)))
      .or()
      .when(eq(constant(x), "test2")).execute(task(id(TASK2)));

      merge(id(MERGE), id(TASK), id(TASK2))
      .end(event(id(END)));
      }
 
 

Parameters:

mergeId - the id of the new merge node

ids - of the nodes to be merged

Returns:

the flow path beginning with the merge node

join

public FlowPathDefinition join(Identifier joinId,
                               Identifier... ids)

create a flow path joining the execution after the given nodes by introducing a new merge join to which the nodes connect. execution will continue only if a token exists for every joined node during the execution of the join node. Example:

  {@literal @}Override public void define() {
      start(event(id(StartEvent)))
      .parallel(id(Parallel))
      .execute(task(id(SecondTask)))
      .and()
      .execute(task(id(ThirdTask)));

      join(id(Join), id(SecondTask), id(ThirdTask))
      .end(event(id(EndEvent2)));
      }
 
 

Parameters:

joinId - the id of the new join node

ids - of the nodes to be merged

Returns:

the flow path beginning with the join node

task

public TaskDefinition task(Identifier id)

task

public TaskDefinition task(Identifier id,
                           Task callee)

create a task definition with the given task to be executed Example:

  {@literal @}Override
      public void define() {
        Task callee = new Task() {
          {@literal @}Override
          public void execute(ExecutionContext o) {
          }
        };

        start(event(id("start")), every(5, TimeUnit.SECONDS))
        .execute(task(id("task"), callee));
      }
 
 

Parameters:

id - the task id

callee - the callee task

Returns:

the task definition with the given task

event

public EventDefinition event(Identifier id)

expression

public <T> Expression expression(T expression)

constant

public <T> Expression<T> constant(T constantValue)

property

public Property property(Identifier id)

property

public <T> T property(Identifier id,
                      Class<T> clazz)

val

public <T> T val(Expression<T> expression)

add a parameter to the invocation arguments of a proxy method call definition.

Type Parameters:

T - the type of the expression

Parameters:

expression - the parameter expression to add

Returns:

null of type T

eq

public EqualDefinition<Expression,Expression<Object>> eq(Expression actual,
                                                         Object expected)

isTrue

public TrueDefinition<Expression> isTrue(Expression actual)

predicate

public <T extends Predicate> PredicateDefinition<T> predicate(T predicate)

method

public InvokeDefinition method(Class<?> clazz)

method

public CallDefinition method(Object returnValueOfProxyInvocation)

service

public <T> T service(Class<T> clazz)

create a service proxy to be user for type-safe call definitions. Example:

  {@literal @}Override
      public void define() {
      TestService testService = service(TestService.class);

      start(event(id(START)))
      .execute(task(id(TASK)).call(method(testService.echo(testService.getString()))))
      .end(event(id(END)));

      }
 
 

Type Parameters:

T - the type of the interface

Parameters:

clazz - the interface type to proxy

Returns:

a service proxy of type T

resultOf

public PredicateBuilder<CallDefinition> resultOf(CallDefinition methodCall)

goal

public GoalDefinition goal(Identifier id)

create a goal definition with the given id. Example:

  {@literal @}Override
      public void define() {
        start(id("start"))
         .execute(task(id("simpleTask"))
         .retryAsync(true)
         .goal(id("taskExecuted")))
        .end(id("end"));

        goal(id("taskExecuted")).check(predicate(new GoalPredicate<Void>() {
          {@literal @}Override
          public boolean isFulfilled(Void aVoid) {
            return true;
          }
        }));
      }
 
 

Parameters:

id - the goal id

Returns:

the goal definition

check

public GoalDefinition check(Identifier id,
                            PredicateDefinition goalPredicate)