/** * Create a new {@link StateMachine} instance with the specified initial * state. This method returns a reference to the {@link StateMachineBuilder} * which allows for adding of transitions to the state machine. * @param initialState The start state of the state machine. * @param <T> The trigger type. * @param <C> The context type. * @return A reference to the {@link StateMachineBuilder} which is used for * creating the {@link StateMachine}. */ @CheckReturnValue public static <T, C> StateMachineBuilder<T, C> create( State<T, C> initialState) { return new StateMachineBuilder<>(initialState); }
.create( builder.getClockMode() == ClockMode.REAL_TIME ? INIT_RT : INIT_ST) .addTransition(INIT_RT, Trigger.SIMULATE, INIT_ST) .addTransition(INIT_RT, Trigger.START, realtimeState) .addTransition(INIT_ST, Trigger.REAL_TIME, INIT_RT) .addTransition(INIT_ST, Trigger.START, st) .addTransition(realtimeState, Trigger.SIMULATE, realtimeState) .addTransition(realtimeState, Trigger.REAL_TIME, realtimeState) .addTransition(realtimeState, Trigger.DO_SIMULATE, st) .addTransition(realtimeState, Trigger.STOP, STOPPED) .addTransition(st, Trigger.REAL_TIME, st) .addTransition(st, Trigger.SIMULATE, st) .addTransition(st, Trigger.DO_REAL_TIME, realtimeState) .addTransition(st, Trigger.STOP, STOPPED) .addTransition(STOPPED, Trigger.STOP, STOPPED) .build();
.addTransition(startState, Events.STOP, stopState) .addTransition(startState, Events.SPEZIAL, specialState) .addTransition(specialState, Events.START, startState) .addTransition(specialState, Events.STOP, specialState) .addTransition(stopState, Events.START, startState) .addTransition(stopState, Events.STOP, stopState) .addTransition(startState, Events.PAUSE, pauseState) .addTransition(pauseState, Events.STOP, stopState) .addTransition(pauseState, Events.START, startState) .addTransition(startState, Events.RECURSIVE, startState) .addTransition(pauseState, Events.RECURSIVE, pauseState) .addTransition(stopState, Events.RECURSIVE, stopState) .addTransition(specialState, Events.RECURSIVE, specialState); smb.explicitRecursiveTransitions(); fsm = smb.build();
final Service service = new Service(); return StateMachine.create(wait) .explicitRecursiveTransitions() .addTransition(wait, DefaultEvent.GOTO, gotos) .addTransition(gotos, DefaultEvent.NOGO, wait) .addTransition(gotos, DefaultEvent.ARRIVED, waitAtService) .addTransition(gotos, DefaultEvent.REROUTE, gotos) .addTransition(waitAtService, DefaultEvent.REROUTE, gotos) .addTransition(waitAtService, DefaultEvent.NOGO, wait) .addTransition(waitAtService, DefaultEvent.READY_TO_SERVICE, service) .addTransition(service, DefaultEvent.DONE, wait).build();
final Service service = new Service(); return StateMachine.create(wait) .explicitRecursiveTransitions() .addTransition(wait, DefaultEvent.GOTO, gotos) .addTransition(gotos, DefaultEvent.NOGO, wait) .addTransition(gotos, DefaultEvent.ARRIVED, waitAtService) .addTransition(gotos, DefaultEvent.REROUTE, gotos) .addTransition(waitAtService, DefaultEvent.REROUTE, gotos) .addTransition(waitAtService, DefaultEvent.NOGO, wait) .addTransition(waitAtService, DefaultEvent.READY_TO_SERVICE, service) .addTransition(service, DefaultEvent.DONE, wait).build();
/** * Tests the query by class method. */ @Test public void testGetStateOfType() { final StateA a = new StateA(); final StateB b = new StateB(); final StateC c = new StateC(); final StateMachineBuilder<Events, Context> smb = StateMachine.create(a) .addTransition(a, Events.START, b) .addTransition(b, Events.START, c) .addTransition(c, Events.START, a); if (explicitRecursiveTransitions) { smb.explicitRecursiveTransitions(); } fsm = smb.build(); final State<Events, Context> first = fsm.getStates().iterator().next(); assertEquals(first, fsm.getStateOfType(Object.class)); assertEquals(b, fsm.getStateOfType(StateB.class)); assertEquals(c, fsm.getStateOfType(StateC.class)); boolean fail = false; try { fsm.getStateOfType(Enum.class); } catch (final IllegalArgumentException e) { fail = true; } assertTrue(fail); }
/** * Tests correct behavior for events which are not equal. */ @SuppressWarnings("static-method") @Test public void eventNotEqualBehavior() { final TestState state1 = new TestState("state1"); state1.name(); final TestState state2 = new TestState("state2"); final Object event1 = "event1"; final Object event2 = new Object(); final StateMachine<Object, Object> sm = StateMachine.create(state1)/* */ .addTransition(state1, event1, state2)/* */ .addTransition(state2, event2, state1)/* */ .build(); assertTrue(sm.isSupported(event1)); assertTrue(sm.isSupported("event1")); assertTrue(sm.isSupported(new StringBuilder("event").append(1) .toString())); assertFalse(sm.isSupported(event2)); sm.handle("event1", CONTEXT); assertTrue(sm.stateIs(state2)); assertTrue(sm.isSupported(event2)); assertFalse(sm.isSupported(new Object())); }
@Override protected StateMachine<StateEvent, RouteFollowingVehicle> createStateMachine() { // when overriding, please see doc of super method! // reuse super implementation final StateMachine<StateEvent, RouteFollowingVehicle> fsm = super.createStateMachine(); // get ref to existing state final Wait wait = fsm.getStateOfType(Wait.class); // add new state final ExtraState extra = new ExtraState(); // add two new transitions return StateMachine.create(wait) .addTransition(wait, ExtraEvent.TEST_EVENT, extra) .addTransition(extra, DefaultEvent.DONE, wait) .addTransitionsFrom(fsm) .build(); }
/** * Create a new {@link StateMachine} instance with the specified initial * state. This method returns a reference to the {@link StateMachineBuilder} * which allows for adding of transitions to the state machine. * @param initialState The start state of the state machine. * @param <T> The trigger type. * @param <C> The context type. * @return A reference to the {@link StateMachineBuilder} which is used for * creating the {@link StateMachine}. */ @CheckReturnValue public static <T, C> StateMachineBuilder<T, C> create( State<T, C> initialState) { return new StateMachineBuilder<>(initialState); }