From 1e3fb046140ec1af9253188f2222716ee7db45d8 Mon Sep 17 00:00:00 2001 From: Janne Valkealahti Date: Sat, 14 Mar 2015 08:20:02 +0000 Subject: [PATCH] Better model for triggers - Harmonise how triggers are used - Now using a trigger context - Creates a better model so that we add more trigger types. --- .../config/EnumStateMachineFactory.java | 5 +- .../support/AbstractStateMachine.java | 79 +++++++++++++------ .../AbstractExternalTransition.java | 5 +- .../AbstractInternalTransition.java | 5 +- .../transition/AbstractLocalTransition.java | 5 +- .../transition/AbstractTransition.java | 7 +- .../transition/DefaultExternalTransition.java | 5 +- .../transition/DefaultInternalTransition.java | 5 +- .../transition/DefaultLocalTransition.java | 5 +- .../trigger/DefaultTriggerContext.java | 31 ++++++++ .../statemachine/trigger/EventTrigger.java | 6 +- .../statemachine/trigger/Trigger.java | 10 ++- .../statemachine/trigger/TriggerContext.java | 22 ++++++ .../statemachine/EnumStateMachineTests.java | 28 ++++--- .../statemachine/RegionMachineTests.java | 17 ++-- .../statemachine/SubStateMachineTests.java | 7 +- .../statemachine/state/RegionStateTests.java | 7 +- .../state/SubmachineStateTests.java | 7 +- 18 files changed, 184 insertions(+), 72 deletions(-) create mode 100644 spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/DefaultTriggerContext.java create mode 100644 spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/TriggerContext.java diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/EnumStateMachineFactory.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/EnumStateMachineFactory.java index 350079fe..c4760bfb 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/EnumStateMachineFactory.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/config/EnumStateMachineFactory.java @@ -44,6 +44,7 @@ import org.springframework.statemachine.transition.DefaultExternalTransition; import org.springframework.statemachine.transition.DefaultInternalTransition; import org.springframework.statemachine.transition.Transition; import org.springframework.statemachine.transition.TransitionKind; +import org.springframework.statemachine.trigger.EventTrigger; import org.springframework.util.ObjectUtils; /** @@ -290,12 +291,12 @@ public class EnumStateMachineFactory, E extends Enum> exten E event = transitionData.getEvent(); if (transitionData.getKind() == TransitionKind.EXTERNAL) { DefaultExternalTransition transition = new DefaultExternalTransition(stateMap.get(source), - stateMap.get(target), transitionData.getActions(), event, transitionData.getGuard()); + stateMap.get(target), transitionData.getActions(), event, transitionData.getGuard(), event != null ? new EventTrigger(event) : null); transitions.add(transition); } else if (transitionData.getKind() == TransitionKind.INTERNAL) { DefaultInternalTransition transition = new DefaultInternalTransition(stateMap.get(source), - transitionData.getActions(), event, transitionData.getGuard()); + transitionData.getActions(), event, transitionData.getGuard(), event != null ? new EventTrigger(event) : null); transitions.add(transition); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java index a4069e8b..6fc87871 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/support/AbstractStateMachine.java @@ -49,6 +49,7 @@ import org.springframework.statemachine.state.PseudoStateKind; import org.springframework.statemachine.state.State; import org.springframework.statemachine.transition.Transition; import org.springframework.statemachine.transition.TransitionKind; +import org.springframework.statemachine.trigger.DefaultTriggerContext; import org.springframework.statemachine.trigger.Trigger; import org.springframework.util.Assert; @@ -91,6 +92,10 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport private volatile boolean handlersInitialized; + private final Queue triggerQueue = new ConcurrentLinkedQueue(); + + private final Map, Transition> triggerToTransitionMap = new HashMap, Transition>(); + /** * Instantiates a new abstract state machine. * @@ -188,6 +193,12 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport Assert.state(initialState.getPseudoState() != null && initialState.getPseudoState().getKind() == PseudoStateKind.INITIAL, "Initial state's pseudostate kind must be INITIAL"); + for (Transition transition : transitions) { + Trigger trigger = transition.getTrigger(); + if (trigger != null) { + triggerToTransitionMap.put(trigger, transition); + } + } } @Override @@ -241,8 +252,8 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport Trigger trigger = transition.getTrigger(); if (StateMachineUtils.containsAtleastOne(source.getIds(), currentState.getIds())) { - if (trigger != null && trigger.evaluate(event.getPayload())) { - eventQueue.add(event); + if (trigger != null && trigger.evaluate(new DefaultTriggerContext(event.getPayload()))) { + triggerQueue.add(new TriggerQueueItem(trigger, event)); return true; } else if (source.getDeferredEvents() != null && source.getDeferredEvents().contains(event.getPayload())) { defer = event; @@ -306,20 +317,11 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport Message defer = null; for (Transition transition : transitions) { State source = transition.getSource(); - State target = transition.getTarget(); Trigger trigger = transition.getTrigger(); if (StateMachineUtils.containsAtleastOne(source.getIds(), currentState.getIds())) { - if (trigger != null && trigger.evaluate(queuedEvent.getPayload())) { - StateContext stateContext = new DefaultStateContext(queuedEvent.getHeaders(), extendedState, transition); - notifyTransitionStart(transition); - boolean transit = transition.transit(stateContext); - if (transit && transition.getKind() != TransitionKind.INTERNAL) { - switchToState(target, queuedEvent, transition); - notifyTransition(transition); - } - notifyTransitionEnd(transition); - break; + if (trigger != null && trigger.evaluate(new DefaultTriggerContext(queuedEvent.getPayload()))) { + triggerQueue.add(new TriggerQueueItem(trigger, queuedEvent)); } else if (source.getDeferredEvents() != null && source.getDeferredEvents().contains(queuedEvent.getPayload())) { defer = queuedEvent; } @@ -332,27 +334,25 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport } } - private void processDeferList() { + private boolean processDeferList() { log.debug("Process defer list"); + boolean triggered = false; ListIterator> iterator = deferList.listIterator(); while (iterator.hasNext()) { Message event = iterator.next(); for (Transition transition : transitions) { State source = transition.getSource(); - State target = transition.getTarget(); Trigger trigger = transition.getTrigger(); if (source.equals(currentState)) { - if (trigger != null && trigger.evaluate(event.getPayload())) { - StateContext stateContext = new DefaultStateContext(event.getHeaders(), extendedState, transition); - boolean transit = transition.transit(stateContext); - if (transit && transition.getKind() != TransitionKind.INTERNAL) { - switchToState(target, event, transition); - } + if (trigger != null && trigger.evaluate(new DefaultTriggerContext(event.getPayload()))) { + triggerQueue.add(new TriggerQueueItem(trigger, event)); iterator.remove(); + triggered = true; } } } } + return triggered; } private void scheduleEventQueueProcessing() { @@ -361,7 +361,10 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport @Override public void run() { processEventQueue(); - processDeferList(); + processTriggerQueue(); + while (processDeferList()) { + processTriggerQueue(); + } task = null; } }; @@ -369,6 +372,29 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport } } + private void processTriggerQueue() { + log.debug("Process trigger queue"); + TriggerQueueItem queueItem = null; + while ((queueItem = triggerQueue.poll()) != null) { + Message queuedEvent = queueItem.message; + Transition transition = triggerToTransitionMap.get(queueItem.trigger); + StateContext stateContext = new DefaultStateContext(queuedEvent.getHeaders(), extendedState, transition); + notifyTransitionStart(transition); + if (transition == null) { + continue; + } + boolean transit = transition.transit(stateContext); + if (transit && transition.getKind() != TransitionKind.INTERNAL) { + switchToState(transition.getTarget(), queuedEvent, transition); + notifyTransition(transition); + } + notifyTransitionEnd(transition); + + + } + + } + private void callHandlers(State sourceState, State targetState, Message event) { @@ -465,4 +491,13 @@ public abstract class AbstractStateMachine extends LifecycleObjectSupport } } + private class TriggerQueueItem { + Trigger trigger; + Message message; + public TriggerQueueItem(Trigger trigger, Message message) { + this.trigger = trigger; + this.message = message; + } + } + } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java index b2478400..83f9eb95 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractExternalTransition.java @@ -20,11 +20,12 @@ import java.util.Collection; import org.springframework.statemachine.action.Action; import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.State; +import org.springframework.statemachine.trigger.Trigger; public abstract class AbstractExternalTransition extends AbstractTransition implements Transition { - public AbstractExternalTransition(State source, State target, Collection> actions, E event, Guard guard) { - super(source, target, actions, event, TransitionKind.EXTERNAL, guard); + public AbstractExternalTransition(State source, State target, Collection> actions, E event, Guard guard, Trigger trigger) { + super(source, target, actions, event, TransitionKind.EXTERNAL, guard, trigger); } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java index 247808d8..8eb38d2e 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractInternalTransition.java @@ -20,11 +20,12 @@ import java.util.Collection; import org.springframework.statemachine.action.Action; import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.State; +import org.springframework.statemachine.trigger.Trigger; public class AbstractInternalTransition extends AbstractTransition implements Transition { - public AbstractInternalTransition(State source,Collection> actions, E event, Guard guard) { - super(source, source, actions, event, TransitionKind.INTERNAL, guard); + public AbstractInternalTransition(State source,Collection> actions, E event, Guard guard, Trigger trigger) { + super(source, source, actions, event, TransitionKind.INTERNAL, guard, trigger); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java index a76acc20..ab0eb881 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractLocalTransition.java @@ -20,11 +20,12 @@ import java.util.Collection; import org.springframework.statemachine.action.Action; import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.State; +import org.springframework.statemachine.trigger.Trigger; public class AbstractLocalTransition extends AbstractTransition implements Transition { - public AbstractLocalTransition(State source, State target,Collection> actions, E event, Guard guard) { - super(source, target, actions, event, TransitionKind.LOCAL, guard); + public AbstractLocalTransition(State source, State target,Collection> actions, E event, Guard guard, Trigger trigger) { + super(source, target, actions, event, TransitionKind.LOCAL, guard, trigger); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java index f2e4b4ab..03128c97 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/AbstractTransition.java @@ -21,7 +21,6 @@ import org.springframework.statemachine.StateContext; import org.springframework.statemachine.action.Action; import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.State; -import org.springframework.statemachine.trigger.EventTrigger; import org.springframework.statemachine.trigger.Trigger; import org.springframework.util.Assert; @@ -48,17 +47,15 @@ public abstract class AbstractTransition implements Transition { private Trigger trigger; public AbstractTransition(State source, State target, Collection> actions, E event, - TransitionKind kind, Guard guard) { + TransitionKind kind, Guard guard, Trigger trigger) { Assert.notNull(source, "Source must be set"); Assert.notNull(kind, "Transition type must be set"); this.source = source; this.target = target; this.actions = actions; - if (event != null) { - this.trigger = new EventTrigger(event); - } this.kind = kind; this.guard = guard; + this.trigger = trigger; } @Override diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java index 9134fe94..4726625c 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultExternalTransition.java @@ -20,11 +20,12 @@ import java.util.Collection; import org.springframework.statemachine.action.Action; import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.State; +import org.springframework.statemachine.trigger.Trigger; public class DefaultExternalTransition extends AbstractExternalTransition { - public DefaultExternalTransition(State source, State target, Collection> actions, E event, Guard guard) { - super(source, target, actions, event, guard); + public DefaultExternalTransition(State source, State target, Collection> actions, E event, Guard guard, Trigger trigger) { + super(source, target, actions, event, guard, trigger); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java index 4a23bf91..538144e5 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultInternalTransition.java @@ -20,11 +20,12 @@ import java.util.Collection; import org.springframework.statemachine.action.Action; import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.State; +import org.springframework.statemachine.trigger.Trigger; public class DefaultInternalTransition extends AbstractInternalTransition { - public DefaultInternalTransition(State source, Collection> actions, E event, Guard guard) { - super(source, actions, event, guard); + public DefaultInternalTransition(State source, Collection> actions, E event, Guard guard, Trigger trigger) { + super(source, actions, event, guard, trigger); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java index f3f4cede..cfd52626 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/transition/DefaultLocalTransition.java @@ -20,11 +20,12 @@ import java.util.Collection; import org.springframework.statemachine.action.Action; import org.springframework.statemachine.guard.Guard; import org.springframework.statemachine.state.State; +import org.springframework.statemachine.trigger.Trigger; public class DefaultLocalTransition extends AbstractLocalTransition { - public DefaultLocalTransition(State source, State target, Collection> actions, E event, Guard guard) { - super(source, target, actions, event, guard); + public DefaultLocalTransition(State source, State target, Collection> actions, E event, Guard guard, Trigger trigger) { + super(source, target, actions, event, guard, trigger); } @Override diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/DefaultTriggerContext.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/DefaultTriggerContext.java new file mode 100644 index 00000000..faf25d17 --- /dev/null +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/DefaultTriggerContext.java @@ -0,0 +1,31 @@ +/* + * Copyright 2015 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.statemachine.trigger; + +public class DefaultTriggerContext implements TriggerContext { + + private final E event; + + public DefaultTriggerContext(E event) { + this.event = event; + } + + @Override + public E getEvent() { + return event; + } + +} diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/EventTrigger.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/EventTrigger.java index d0548226..0e6ee021 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/EventTrigger.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/EventTrigger.java @@ -15,6 +15,8 @@ */ package org.springframework.statemachine.trigger; +import org.springframework.util.ObjectUtils; + public class EventTrigger implements Trigger { private final E event; @@ -24,8 +26,8 @@ public class EventTrigger implements Trigger { } @Override - public boolean evaluate(E event) { - return this.event.equals(event); + public boolean evaluate(TriggerContext context) { + return ObjectUtils.nullSafeEquals(event, context.getEvent()); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/Trigger.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/Trigger.java index 17f05175..0b5f7e88 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/Trigger.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/Trigger.java @@ -20,7 +20,7 @@ import org.springframework.statemachine.transition.Transition; /** * {@code Trigger} is the cause of the {@link Transition}. Cause is usually an * event but can be some other signal or a change in some condition. - * + * * @author Janne Valkealahti * * @param the type of state @@ -28,6 +28,12 @@ import org.springframework.statemachine.transition.Transition; */ public interface Trigger { - boolean evaluate(E event); + /** + * Evaluate trigger. + * + * @param context the context + * @return true, triggers is fired, false otherwise + */ + boolean evaluate(TriggerContext context); } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/TriggerContext.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/TriggerContext.java new file mode 100644 index 00000000..3e6f807b --- /dev/null +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/trigger/TriggerContext.java @@ -0,0 +1,22 @@ +/* + * Copyright 2015 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.statemachine.trigger; + +public interface TriggerContext { + + E getEvent(); + +} diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java index 4af99b5b..a9f6c2ee 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/EnumStateMachineTests.java @@ -27,18 +27,22 @@ import org.junit.Test; import org.springframework.core.task.SyncTaskExecutor; import org.springframework.messaging.support.MessageBuilder; import org.springframework.statemachine.action.Action; +import org.springframework.statemachine.state.DefaultPseudoState; import org.springframework.statemachine.state.EnumState; +import org.springframework.statemachine.state.PseudoState; +import org.springframework.statemachine.state.PseudoStateKind; import org.springframework.statemachine.state.State; import org.springframework.statemachine.transition.DefaultExternalTransition; import org.springframework.statemachine.transition.DefaultInternalTransition; import org.springframework.statemachine.transition.Transition; +import org.springframework.statemachine.trigger.EventTrigger; public class EnumStateMachineTests extends AbstractStateMachineTests { @Test public void testSimpleStateSwitch() { - - State stateSI = new EnumState(TestStates.SI); + PseudoState pseudoState = new DefaultPseudoState(PseudoStateKind.INITIAL); + State stateSI = new EnumState(TestStates.SI, pseudoState); State stateS1 = new EnumState(TestStates.S1); State stateS2 = new EnumState(TestStates.S2); State stateS3 = new EnumState(TestStates.S3); @@ -54,17 +58,17 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { Collection> actionsFromSIToS1 = new ArrayList>(); actionsFromSIToS1.add(new LoggingAction("actionsFromSIToS1")); DefaultExternalTransition transitionFromSIToS1 = - new DefaultExternalTransition(stateSI, stateS1, actionsFromSIToS1, TestEvents.E1, null); + new DefaultExternalTransition(stateSI, stateS1, actionsFromSIToS1, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); Collection> actionsFromS1ToS2 = new ArrayList>(); actionsFromS1ToS2.add(new LoggingAction("actionsFromS1ToS2")); DefaultExternalTransition transitionFromS1ToS2 = - new DefaultExternalTransition(stateS1, stateS2, actionsFromS1ToS2, TestEvents.E2, null); + new DefaultExternalTransition(stateS1, stateS2, actionsFromS1ToS2, TestEvents.E2, null, new EventTrigger(TestEvents.E2)); Collection> actionsFromS2ToS3 = new ArrayList>(); actionsFromS1ToS2.add(new LoggingAction("actionsFromS2ToS3")); DefaultExternalTransition transitionFromS2ToS3 = - new DefaultExternalTransition(stateS2, stateS3, actionsFromS2ToS3, TestEvents.E3, null); + new DefaultExternalTransition(stateS2, stateS3, actionsFromS2ToS3, TestEvents.E3, null, new EventTrigger(TestEvents.E3)); transitions.add(transitionFromSIToS1); transitions.add(transitionFromS1ToS2); @@ -73,6 +77,7 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { SyncTaskExecutor taskExecutor = new SyncTaskExecutor(); EnumStateMachine machine = new EnumStateMachine(states, transitions, stateSI, null); machine.setTaskExecutor(taskExecutor); + machine.afterPropertiesSet(); machine.start(); State initialState = machine.getInitialState(); @@ -101,13 +106,14 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { @Test public void testDeferredEvents() { + PseudoState pseudoState = new DefaultPseudoState(PseudoStateKind.INITIAL); Collection deferred = new ArrayList(); deferred.add(TestEvents.E2); deferred.add(TestEvents.E3); // states - State stateSI = new EnumState(TestStates.SI, deferred); + State stateSI = new EnumState(TestStates.SI, deferred, null, null, pseudoState); State stateS1 = new EnumState(TestStates.S1); State stateS2 = new EnumState(TestStates.S2); State stateS3 = new EnumState(TestStates.S3); @@ -124,17 +130,17 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { Collection> actionsFromSIToS1 = new ArrayList>(); actionsFromSIToS1.add(new LoggingAction("actionsFromSIToS1")); DefaultExternalTransition transitionFromSIToS1 = - new DefaultExternalTransition(stateSI, stateS1, actionsFromSIToS1, TestEvents.E1, null); + new DefaultExternalTransition(stateSI, stateS1, actionsFromSIToS1, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); Collection> actionsFromS1ToS2 = new ArrayList>(); actionsFromS1ToS2.add(new LoggingAction("actionsFromS1ToS2")); DefaultExternalTransition transitionFromS1ToS2 = - new DefaultExternalTransition(stateS1, stateS2, actionsFromS1ToS2, TestEvents.E2, null); + new DefaultExternalTransition(stateS1, stateS2, actionsFromS1ToS2, TestEvents.E2, null, new EventTrigger(TestEvents.E2)); Collection> actionsFromS2ToS3 = new ArrayList>(); actionsFromS1ToS2.add(new LoggingAction("actionsFromS2ToS3")); DefaultExternalTransition transitionFromS2ToS3 = - new DefaultExternalTransition(stateS2, stateS3, actionsFromS2ToS3, TestEvents.E3, null); + new DefaultExternalTransition(stateS2, stateS3, actionsFromS2ToS3, TestEvents.E3, null, new EventTrigger(TestEvents.E3)); transitions.add(transitionFromSIToS1); transitions.add(transitionFromS1ToS2); @@ -143,8 +149,8 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { // create machine SyncTaskExecutor taskExecutor = new SyncTaskExecutor(); EnumStateMachine machine = new EnumStateMachine(states, transitions, stateSI, null); -// StateMachine, TestEvents> machine2 = new EnumStateMachine(states, transitions, stateSI); machine.setTaskExecutor(taskExecutor); + machine.afterPropertiesSet(); machine.start(); State initialState = machine.getInitialState(); @@ -175,7 +181,7 @@ public class EnumStateMachineTests extends AbstractStateMachineTests { Collection> actionsInSI = new ArrayList>(); actionsInSI.add(new LoggingAction("actionsInSI")); DefaultInternalTransition transitionInternalSI = - new DefaultInternalTransition(stateSI, actionsInSI, TestEvents.E1, null); + new DefaultInternalTransition(stateSI, actionsInSI, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); // transitions Collection> transitions = new ArrayList>(); diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java index 2625749b..1338f245 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/RegionMachineTests.java @@ -39,6 +39,7 @@ import org.springframework.statemachine.state.RegionState; import org.springframework.statemachine.state.State; import org.springframework.statemachine.transition.DefaultExternalTransition; import org.springframework.statemachine.transition.Transition; +import org.springframework.statemachine.trigger.EventTrigger; /** * Statemachine tests using regions. @@ -50,6 +51,7 @@ public class RegionMachineTests { @Test public void testSimpleRegion() throws Exception { + PseudoState pseudoState = new DefaultPseudoState(PseudoStateKind.INITIAL); TestEntryAction entryActionS1 = new TestEntryAction("S1"); TestExitAction exitActionS1 = new TestExitAction("S1"); Collection> entryActionsS1 = new ArrayList>(); @@ -58,7 +60,7 @@ public class RegionMachineTests { exitActionsS1.add(exitActionS1); - State stateSI = new EnumState(TestStates.SI); + State stateSI = new EnumState(TestStates.SI, pseudoState); State stateS1 = new EnumState(TestStates.S1, null, entryActionsS1, exitActionsS1); State stateS2 = new EnumState(TestStates.S2); State stateS3 = new EnumState(TestStates.S3); @@ -72,13 +74,13 @@ public class RegionMachineTests { Collection> transitions = new ArrayList>(); DefaultExternalTransition transitionFromSIToS1 = - new DefaultExternalTransition(stateSI, stateS1, null, TestEvents.E1, null); + new DefaultExternalTransition(stateSI, stateS1, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); DefaultExternalTransition transitionFromS1ToS2 = - new DefaultExternalTransition(stateS1, stateS2, null, TestEvents.E2, null); + new DefaultExternalTransition(stateS1, stateS2, null, TestEvents.E2, null, new EventTrigger(TestEvents.E2)); DefaultExternalTransition transitionFromS2ToS3 = - new DefaultExternalTransition(stateS2, stateS3, null, TestEvents.E3, null); + new DefaultExternalTransition(stateS2, stateS3, null, TestEvents.E3, null, new EventTrigger(TestEvents.E3)); transitions.add(transitionFromSIToS1); transitions.add(transitionFromS1ToS2); @@ -87,6 +89,7 @@ public class RegionMachineTests { SyncTaskExecutor taskExecutor = new SyncTaskExecutor(); EnumStateMachine machine = new EnumStateMachine(states, transitions, stateSI, null); machine.setTaskExecutor(taskExecutor); + machine.afterPropertiesSet(); machine.start(); Collection> regions = new ArrayList>(); @@ -145,7 +148,7 @@ public class RegionMachineTests { states11.add(stateS112); Collection> transitions11 = new ArrayList>(); DefaultExternalTransition transitionFromS111ToS112 = - new DefaultExternalTransition(stateS111, stateS112, null, TestEvents.E2, null); + new DefaultExternalTransition(stateS111, stateS112, null, TestEvents.E2, null, new EventTrigger(TestEvents.E2)); transitions11.add(transitionFromS111ToS112); EnumStateMachine machine11 = new EnumStateMachine(states11, transitions11, stateS111, null); machine11.setTaskExecutor(taskExecutor); @@ -156,7 +159,7 @@ public class RegionMachineTests { states12.add(stateS121); Collection> transitions12 = new ArrayList>(); DefaultExternalTransition transitionFromSIToS121 = - new DefaultExternalTransition(stateSI, stateS111, null, TestEvents.E3, null); + new DefaultExternalTransition(stateSI, stateS111, null, TestEvents.E3, null, new EventTrigger(TestEvents.E3)); transitions12.add(transitionFromSIToS121); EnumStateMachine machine12 = new EnumStateMachine(states12, transitions12, stateS121, null); machine12.setTaskExecutor(taskExecutor); @@ -171,7 +174,7 @@ public class RegionMachineTests { states.add(stateR); Collection> transitions = new ArrayList>(); DefaultExternalTransition transitionFromSIToRegionstate = - new DefaultExternalTransition(stateSI, stateR, null, TestEvents.E1, null); + new DefaultExternalTransition(stateSI, stateR, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); transitions.add(transitionFromSIToRegionstate); EnumStateMachine machine = new EnumStateMachine(states, transitions, stateR, null); diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java index a313cb54..f94f881f 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/SubStateMachineTests.java @@ -46,6 +46,7 @@ import org.springframework.statemachine.state.StateMachineState; import org.springframework.statemachine.transition.DefaultExternalTransition; import org.springframework.statemachine.transition.DefaultLocalTransition; import org.springframework.statemachine.transition.Transition; +import org.springframework.statemachine.trigger.EventTrigger; public class SubStateMachineTests extends AbstractStateMachineTests { @@ -122,7 +123,7 @@ public class SubStateMachineTests extends AbstractStateMachineTests { states.add(stateS1); Collection> transitions = new ArrayList>(); DefaultExternalTransition transitionFromS111ToS1 = - new DefaultExternalTransition(stateS111, stateS1, null, TestEvents.E1, null); + new DefaultExternalTransition(stateS111, stateS1, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); transitions.add(transitionFromS111ToS1); EnumStateMachine machine = new EnumStateMachine(states, transitions, stateS1, null); @@ -212,7 +213,7 @@ public class SubStateMachineTests extends AbstractStateMachineTests { states.add(stateS1); Collection> transitions = new ArrayList>(); DefaultExternalTransition transitionFromS111ToS112 = - new DefaultExternalTransition(stateS111, stateS112, null, TestEvents.E1, null); + new DefaultExternalTransition(stateS111, stateS112, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); transitions.add(transitionFromS111ToS112); EnumStateMachine machine = new EnumStateMachine(states, transitions, stateS1, null); @@ -309,7 +310,7 @@ public class SubStateMachineTests extends AbstractStateMachineTests { states.add(stateS1); Collection> transitions = new ArrayList>(); DefaultLocalTransition transitionFromS11ToS1 = - new DefaultLocalTransition(stateS111, stateS1, null, TestEvents.E1, null); + new DefaultLocalTransition(stateS111, stateS1, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); transitions.add(transitionFromS11ToS1); EnumStateMachine machine = new EnumStateMachine(states, transitions, stateS1, null); diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java index ed0613cc..68997f9e 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/RegionStateTests.java @@ -29,6 +29,7 @@ import org.springframework.statemachine.EnumStateMachine; import org.springframework.statemachine.region.Region; import org.springframework.statemachine.transition.DefaultExternalTransition; import org.springframework.statemachine.transition.Transition; +import org.springframework.statemachine.trigger.EventTrigger; /** * Tests for states using a submachine. @@ -55,13 +56,13 @@ public class RegionStateTests extends AbstractStateMachineTests { Collection> transitions = new ArrayList>(); DefaultExternalTransition transitionFromSIToS1 = - new DefaultExternalTransition(stateSI, stateS1, null, TestEvents.E1, null); + new DefaultExternalTransition(stateSI, stateS1, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); DefaultExternalTransition transitionFromS1ToS2 = - new DefaultExternalTransition(stateS1, stateS2, null, TestEvents.E2, null); + new DefaultExternalTransition(stateS1, stateS2, null, TestEvents.E2, null, new EventTrigger(TestEvents.E2)); DefaultExternalTransition transitionFromS2ToS3 = - new DefaultExternalTransition(stateS2, stateS3, null, TestEvents.E3, null); + new DefaultExternalTransition(stateS2, stateS3, null, TestEvents.E3, null, new EventTrigger(TestEvents.E3)); transitions.add(transitionFromSIToS1); transitions.add(transitionFromS1ToS2); diff --git a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java index aa2ada63..fc63e3c6 100644 --- a/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java +++ b/spring-statemachine-core/src/test/java/org/springframework/statemachine/state/SubmachineStateTests.java @@ -28,6 +28,7 @@ import org.springframework.statemachine.AbstractStateMachineTests; import org.springframework.statemachine.EnumStateMachine; import org.springframework.statemachine.transition.DefaultExternalTransition; import org.springframework.statemachine.transition.Transition; +import org.springframework.statemachine.trigger.EventTrigger; /** * Tests for states using a submachine. @@ -54,13 +55,13 @@ public class SubmachineStateTests extends AbstractStateMachineTests { Collection> transitions = new ArrayList>(); DefaultExternalTransition transitionFromSIToS1 = - new DefaultExternalTransition(stateSI, stateS1, null, TestEvents.E1, null); + new DefaultExternalTransition(stateSI, stateS1, null, TestEvents.E1, null, new EventTrigger(TestEvents.E1)); DefaultExternalTransition transitionFromS1ToS2 = - new DefaultExternalTransition(stateS1, stateS2, null, TestEvents.E2, null); + new DefaultExternalTransition(stateS1, stateS2, null, TestEvents.E2, null, new EventTrigger(TestEvents.E2)); DefaultExternalTransition transitionFromS2ToS3 = - new DefaultExternalTransition(stateS2, stateS3, null, TestEvents.E3, null); + new DefaultExternalTransition(stateS2, stateS3, null, TestEvents.E3, null, new EventTrigger(TestEvents.E3)); transitions.add(transitionFromSIToS1); transitions.add(transitionFromS1ToS2);