Example usage for org.springframework.statemachine.state PseudoStateKind INITIAL

List of usage examples for org.springframework.statemachine.state PseudoStateKind INITIAL

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.statemachine.state.*
  5. PseudoStateKind
  6. INITIAL

Introduction

In this page you can find the example usage for org.springframework.statemachine.state PseudoStateKind INITIAL.

Prototype

PseudoStateKind INITIAL

To view the source code for org.springframework.statemachine.state PseudoStateKind INITIAL.

Click Source Link

Document

Indicates an initial kind.

Usage

From source file:org.springframework.statemachine.config.AbstractStateMachineFactory.java

/**
 * Main constructor that create a {@link StateMachine}.
 *
 * @param uuid for internal usage. Can be null, in that case a random one will be generated.
 * @param machineId represent a user Id, up to you to set what you want.
 * @return a {@link StateMachine}/*  w w  w .j  a  v  a2s . c o m*/
 */
@SuppressWarnings("unchecked")
public StateMachine<S, E> getStateMachine(UUID uuid, String machineId) {
    StateMachineModel<S, E> stateMachineModel = resolveStateMachineModel(machineId);
    if (stateMachineModel.getConfigurationData().isVerifierEnabled()) {
        StateMachineModelVerifier<S, E> verifier = stateMachineModel.getConfigurationData().getVerifier();
        if (verifier == null) {
            verifier = new CompositeStateMachineModelVerifier<S, E>();
        }
        verifier.verify(stateMachineModel);
    }

    // shared
    DefaultExtendedState defaultExtendedState = new DefaultExtendedState();

    StateMachine<S, E> machine = null;

    // we store mappings from state id's to states which gets
    // created during the process. This is needed for transitions to
    // find a correct mappings because they use state id's, not actual
    // states.
    final Map<S, State<S, E>> stateMap = new HashMap<S, State<S, E>>();
    Stack<MachineStackItem<S, E>> regionStack = new Stack<MachineStackItem<S, E>>();
    Stack<StateData<S, E>> stateStack = new Stack<StateData<S, E>>();
    Map<Object, StateMachine<S, E>> machineMap = new HashMap<Object, StateMachine<S, E>>();
    Map<S, StateHolder<S, E>> holderMap = new HashMap<S, StateHolder<S, E>>();

    Iterator<Node<StateData<S, E>>> iterator = buildStateDataIterator(stateMachineModel);
    while (iterator.hasNext()) {
        Node<StateData<S, E>> node = iterator.next();
        StateData<S, E> stateData = node.getData();
        StateData<S, E> peek = stateStack.isEmpty() ? null : stateStack.peek();

        // simply push and continue
        if (stateStack.isEmpty()) {
            stateStack.push(stateData);
            continue;
        }

        boolean stackContainsSameParent = false;
        Iterator<StateData<S, E>> ii = stateStack.iterator();
        while (ii.hasNext()) {
            StateData<S, E> sd = ii.next();
            if (stateData != null && ObjectUtils.nullSafeEquals(stateData.getState(), sd.getParent())) {
                stackContainsSameParent = true;
                break;
            }
        }

        if (stateData != null && !stackContainsSameParent) {
            stateStack.push(stateData);
            continue;
        }

        Collection<StateData<S, E>> stateDatas = popSameParents(stateStack);
        int initialCount = getInitialCount(stateDatas);
        Collection<Collection<StateData<S, E>>> regionsStateDatas = splitIntoRegions(stateDatas);
        Collection<TransitionData<S, E>> transitionsData = getTransitionData(iterator.hasNext(), stateDatas,
                stateMachineModel);

        if (initialCount > 1) {
            for (Collection<StateData<S, E>> regionStateDatas : regionsStateDatas) {
                machine = buildMachine(machineMap, stateMap, holderMap, regionStateDatas, transitionsData,
                        resolveBeanFactory(stateMachineModel), contextEvents, defaultExtendedState,
                        stateMachineModel.getTransitionsData(), resolveTaskExecutor(stateMachineModel),
                        resolveTaskScheduler(stateMachineModel), machineId, null, stateMachineModel);
                regionStack.push(new MachineStackItem<S, E>(machine));
            }

            Collection<Region<S, E>> regions = new ArrayList<Region<S, E>>();
            while (!regionStack.isEmpty()) {
                MachineStackItem<S, E> pop = regionStack.pop();
                regions.add(pop.machine);
            }
            S parent = (S) peek.getParent();
            RegionState<S, E> rstate = buildRegionStateInternal(parent, regions, null,
                    stateData != null ? stateData.getEntryActions() : null,
                    stateData != null ? stateData.getExitActions() : null,
                    new DefaultPseudoState<S, E>(PseudoStateKind.INITIAL));
            if (stateData != null) {
                stateMap.put(stateData.getState(), rstate);
            } else {
                // TODO: don't like that we create a last machine here
                Collection<State<S, E>> states = new ArrayList<State<S, E>>();
                states.add(rstate);
                Transition<S, E> initialTransition = new InitialTransition<S, E>(rstate);
                StateMachine<S, E> m = buildStateMachineInternal(states, new ArrayList<Transition<S, E>>(),
                        rstate, initialTransition, null, defaultExtendedState, null, contextEvents,
                        resolveBeanFactory(stateMachineModel), resolveTaskExecutor(stateMachineModel),
                        resolveTaskScheduler(stateMachineModel), beanName,
                        machineId != null ? machineId : stateMachineModel.getConfigurationData().getMachineId(),
                        uuid, stateMachineModel);
                machine = m;
            }
        } else {
            machine = buildMachine(machineMap, stateMap, holderMap, stateDatas, transitionsData,
                    resolveBeanFactory(stateMachineModel), contextEvents, defaultExtendedState,
                    stateMachineModel.getTransitionsData(), resolveTaskExecutor(stateMachineModel),
                    resolveTaskScheduler(stateMachineModel), machineId, uuid, stateMachineModel);
            if (peek.isInitial() || (!peek.isInitial() && !machineMap.containsKey(peek.getParent()))) {
                machineMap.put(peek.getParent(), machine);
            }
        }

        stateStack.push(stateData);
    }

    // setup autostart for top-level machine
    if (machine instanceof LifecycleObjectSupport) {
        ((LifecycleObjectSupport) machine)
                .setAutoStartup(stateMachineModel.getConfigurationData().isAutoStart());
    }

    // set top-level machine as relay
    final StateMachine<S, E> fmachine = machine;
    fmachine.getStateMachineAccessor().doWithAllRegions(new StateMachineFunction<StateMachineAccess<S, E>>() {

        @Override
        public void apply(StateMachineAccess<S, E> function) {
            function.setRelay(fmachine);
        }
    });

    // add monitoring hooks
    final StateMachineMonitor<S, E> stateMachineMonitor = stateMachineModel.getConfigurationData()
            .getStateMachineMonitor();
    if (stateMachineMonitor != null || defaultStateMachineMonitor != null) {
        fmachine.getStateMachineAccessor().doWithRegion(new StateMachineFunction<StateMachineAccess<S, E>>() {

            @Override
            public void apply(StateMachineAccess<S, E> function) {
                if (defaultStateMachineMonitor != null) {
                    function.addStateMachineMonitor(defaultStateMachineMonitor);
                }
                if (stateMachineMonitor != null) {
                    function.addStateMachineMonitor(stateMachineMonitor);
                }
            }
        });
    }

    // TODO: should error out if sec is enabled but spring-security is not in cp
    if (stateMachineModel.getConfigurationData().isSecurityEnabled()) {
        final StateMachineSecurityInterceptor<S, E> securityInterceptor = new StateMachineSecurityInterceptor<S, E>(
                stateMachineModel.getConfigurationData().getTransitionSecurityAccessDecisionManager(),
                stateMachineModel.getConfigurationData().getEventSecurityAccessDecisionManager(),
                stateMachineModel.getConfigurationData().getEventSecurityRule());
        log.info("Adding security interceptor " + securityInterceptor);
        fmachine.getStateMachineAccessor()
                .doWithAllRegions(new StateMachineFunction<StateMachineAccess<S, E>>() {

                    @Override
                    public void apply(StateMachineAccess<S, E> function) {
                        function.addStateMachineInterceptor(securityInterceptor);
                    }
                });
    }

    // setup distributed state machine if needed.
    // we wrap previously build machine with a distributed
    // state machine and set it to use given ensemble.
    if (stateMachineModel.getConfigurationData().getStateMachineEnsemble() != null) {
        DistributedStateMachine<S, E> distributedStateMachine = new DistributedStateMachine<S, E>(
                stateMachineModel.getConfigurationData().getStateMachineEnsemble(), machine);
        distributedStateMachine.setAutoStartup(stateMachineModel.getConfigurationData().isAutoStart());
        distributedStateMachine.afterPropertiesSet();
        machine = distributedStateMachine;
    }

    for (StateMachineListener<S, E> listener : stateMachineModel.getConfigurationData()
            .getStateMachineListeners()) {
        machine.addStateListener(listener);
    }

    // go through holders and fix state references which
    // were not known at a time holder was created
    for (Entry<S, StateHolder<S, E>> holder : holderMap.entrySet()) {
        holder.getValue().setState(stateMap.get(holder.getKey()));
    }

    return delegateAutoStartup(machine);
}

From source file:org.springframework.statemachine.config.AbstractStateMachineFactory.java

@SuppressWarnings("unchecked")
private StateMachine<S, E> buildMachine(Map<Object, StateMachine<S, E>> machineMap,
        Map<S, State<S, E>> stateMap, Map<S, StateHolder<S, E>> holderMap,
        Collection<StateData<S, E>> stateDatas, Collection<TransitionData<S, E>> transitionsData,
        BeanFactory beanFactory, Boolean contextEvents, DefaultExtendedState defaultExtendedState,
        TransitionsData<S, E> stateMachineTransitions, TaskExecutor taskExecutor, TaskScheduler taskScheduler,
        String machineId, UUID uuid, StateMachineModel<S, E> stateMachineModel) {
    State<S, E> state = null;
    State<S, E> initialState = null;
    PseudoState<S, E> historyState = null;
    Action<S, E> initialAction = null;
    Collection<State<S, E>> states = new ArrayList<State<S, E>>();

    // for now loop twice and build states for
    // non initial/end pseudostates last

    for (StateData<S, E> stateData : stateDatas) {
        StateMachine<S, E> stateMachine = machineMap.get(stateData.getState());
        if (stateMachine == null) {
            // get a submachine from state data if we didn't have
            // it already. stays null if we don't have one.
            stateMachine = stateData.getSubmachine();
            if (stateMachine == null && stateData.getSubmachineFactory() != null) {
                stateMachine = stateData.getSubmachineFactory().getStateMachine(machineId);
            }//  w w w. j ava 2  s .c om
        }
        state = stateMap.get(stateData.getState());
        if (state != null) {
            states.add(state);
            if (stateData.isInitial()) {
                initialState = state;
            }
            continue;
        }
        if (stateMachine != null) {
            PseudoState<S, E> pseudoState = null;
            if (stateData.isInitial()) {
                pseudoState = new DefaultPseudoState<S, E>(PseudoStateKind.INITIAL);
            }
            state = new StateMachineState<S, E>(stateData.getState(), stateMachine, stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), pseudoState);
            // TODO: below if/else doesn't feel right
            if (stateDatas.size() > 1 && stateData.isInitial()) {
                initialState = state;
                initialAction = stateData.getInitialAction();
            } else if (stateDatas.size() == 1) {
                initialState = state;
                initialAction = stateData.getInitialAction();
            }
            states.add(state);
        } else {
            PseudoState<S, E> pseudoState = null;
            if (stateData.isInitial()) {
                pseudoState = new DefaultPseudoState<S, E>(PseudoStateKind.INITIAL);
            } else if (stateData.isEnd()) {
                pseudoState = new DefaultPseudoState<S, E>(PseudoStateKind.END);
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.HISTORY_SHALLOW) {
                continue;
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.HISTORY_DEEP) {
                continue;
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.JOIN) {
                continue;
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.FORK) {
                continue;
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.CHOICE) {
                continue;
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.JUNCTION) {
                continue;
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.ENTRY) {
                continue;
            } else if (stateData.getPseudoStateKind() == PseudoStateKind.EXIT) {
                continue;
            }
            state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), stateData.getStateActions(),
                    pseudoState, stateMachineModel);
            if (stateData.isInitial()) {
                initialState = state;
                initialAction = stateData.getInitialAction();
            }
            states.add(state);

        }
        stateMap.put(stateData.getState(), state);
    }

    for (StateData<S, E> stateData : stateDatas) {
        if (stateData.getPseudoStateKind() == PseudoStateKind.HISTORY_SHALLOW) {
            State<S, E> defaultState = null;
            S s = stateData.getState();
            Collection<HistoryData<S, E>> historys = stateMachineTransitions.getHistorys();
            for (HistoryData<S, E> history : historys) {
                if (history.getSource().equals(s)) {
                    defaultState = stateMap.get(history.getTarget());
                }
            }
            StateHolder<S, E> defaultStateHolder = new StateHolder<S, E>(defaultState);
            StateHolder<S, E> containingStateHolder = new StateHolder<S, E>(
                    stateMap.get(stateData.getParent()));
            if (containingStateHolder.getState() == null) {
                holderMap.put((S) stateData.getParent(), containingStateHolder);
            }
            PseudoState<S, E> pseudoState = new HistoryPseudoState<S, E>(PseudoStateKind.HISTORY_SHALLOW,
                    defaultStateHolder, containingStateHolder);
            state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), stateData.getStateActions(),
                    pseudoState, stateMachineModel);
            states.add(state);
            stateMap.put(stateData.getState(), state);
            historyState = pseudoState;
        } else if (stateData.getPseudoStateKind() == PseudoStateKind.HISTORY_DEEP) {
            State<S, E> defaultState = null;
            S s = stateData.getState();
            Collection<HistoryData<S, E>> historys = stateMachineTransitions.getHistorys();
            for (HistoryData<S, E> history : historys) {
                if (history.getSource().equals(s)) {
                    defaultState = stateMap.get(history.getTarget());
                }
            }
            StateHolder<S, E> defaultStateHolder = new StateHolder<S, E>(defaultState);
            StateHolder<S, E> containingStateHolder = new StateHolder<S, E>(
                    stateMap.get(stateData.getParent()));
            if (containingStateHolder.getState() == null) {
                holderMap.put((S) stateData.getParent(), containingStateHolder);
            }
            PseudoState<S, E> pseudoState = new HistoryPseudoState<S, E>(PseudoStateKind.HISTORY_DEEP,
                    defaultStateHolder, containingStateHolder);
            state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), stateData.getStateActions(),
                    pseudoState, stateMachineModel);
            states.add(state);
            stateMap.put(stateData.getState(), state);
            historyState = pseudoState;
        }

        if (stateData.getPseudoStateKind() == PseudoStateKind.CHOICE) {
            S s = stateData.getState();
            List<ChoiceData<S, E>> list = stateMachineTransitions.getChoices().get(s);
            List<ChoiceStateData<S, E>> choices = new ArrayList<ChoiceStateData<S, E>>();
            for (ChoiceData<S, E> c : list) {
                StateHolder<S, E> holder = new StateHolder<S, E>(stateMap.get(c.getTarget()));
                if (holder.getState() == null) {
                    holderMap.put(c.getTarget(), holder);
                }
                choices.add(new ChoiceStateData<S, E>(holder, c.getGuard()));
            }
            PseudoState<S, E> pseudoState = new ChoicePseudoState<S, E>(choices);
            state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), stateData.getStateActions(),
                    pseudoState, stateMachineModel);
            states.add(state);
            stateMap.put(stateData.getState(), state);
        } else if (stateData.getPseudoStateKind() == PseudoStateKind.JUNCTION) {
            S s = stateData.getState();
            List<JunctionData<S, E>> list = stateMachineTransitions.getJunctions().get(s);
            List<JunctionStateData<S, E>> junctions = new ArrayList<JunctionStateData<S, E>>();
            for (JunctionData<S, E> c : list) {
                StateHolder<S, E> holder = new StateHolder<S, E>(stateMap.get(c.getTarget()));
                if (holder.getState() == null) {
                    holderMap.put(c.getTarget(), holder);
                }
                junctions.add(new JunctionStateData<S, E>(holder, c.getGuard()));
            }
            PseudoState<S, E> pseudoState = new JunctionPseudoState<S, E>(junctions);
            state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), stateData.getStateActions(),
                    pseudoState, stateMachineModel);
            states.add(state);
            stateMap.put(stateData.getState(), state);
        } else if (stateData.getPseudoStateKind() == PseudoStateKind.ENTRY) {
            S s = stateData.getState();
            Collection<EntryData<S, E>> entrys = stateMachineTransitions.getEntrys();
            for (EntryData<S, E> entry : entrys) {
                if (s.equals(entry.getSource())) {
                    PseudoState<S, E> pseudoState = new EntryPseudoState<S, E>(stateMap.get(entry.getTarget()));
                    state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                            stateData.getEntryActions(), stateData.getExitActions(),
                            stateData.getStateActions(), pseudoState, stateMachineModel);
                    states.add(state);
                    stateMap.put(stateData.getState(), state);
                    break;
                }
            }
        } else if (stateData.getPseudoStateKind() == PseudoStateKind.EXIT) {
            S s = stateData.getState();
            Collection<ExitData<S, E>> exits = stateMachineTransitions.getExits();
            for (ExitData<S, E> entry : exits) {
                if (s.equals(entry.getSource())) {
                    StateHolder<S, E> holder = new StateHolder<S, E>(stateMap.get(entry.getTarget()));
                    if (holder.getState() == null) {
                        holderMap.put(entry.getTarget(), holder);
                    }
                    PseudoState<S, E> pseudoState = new ExitPseudoState<S, E>(holder);
                    state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                            stateData.getEntryActions(), stateData.getExitActions(),
                            stateData.getStateActions(), pseudoState, stateMachineModel);
                    states.add(state);
                    stateMap.put(stateData.getState(), state);
                    break;
                }
            }
        } else if (stateData.getPseudoStateKind() == PseudoStateKind.FORK) {
            S s = stateData.getState();
            List<S> list = stateMachineTransitions.getForks().get(s);
            List<State<S, E>> forks = new ArrayList<State<S, E>>();
            for (S fs : list) {
                forks.add(stateMap.get(fs));
            }
            PseudoState<S, E> pseudoState = new ForkPseudoState<S, E>(forks);
            state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), stateData.getStateActions(),
                    pseudoState, stateMachineModel);
            states.add(state);
            stateMap.put(stateData.getState(), state);
        } else if (stateData.getPseudoStateKind() == PseudoStateKind.JOIN) {
            S s = stateData.getState();
            List<S> list = stateMachineTransitions.getJoins().get(s);
            List<State<S, E>> joins = new ArrayList<State<S, E>>();

            // if join source is a regionstate, get
            // it's end states from regions
            if (list.size() == 1) {
                State<S, E> ss1 = stateMap.get(list.get(0));
                if (ss1 instanceof RegionState) {
                    Collection<Region<S, E>> regions = ((RegionState<S, E>) ss1).getRegions();
                    for (Region<S, E> r : regions) {
                        Collection<State<S, E>> ss2 = r.getStates();
                        for (State<S, E> ss3 : ss2) {
                            if (ss3.getPseudoState() != null
                                    && ss3.getPseudoState().getKind() == PseudoStateKind.END) {
                                joins.add(ss3);
                                continue;
                            }
                        }
                    }
                }
            } else {
                for (S fs : list) {
                    joins.add(stateMap.get(fs));
                }
            }

            List<JoinStateData<S, E>> joinTargets = new ArrayList<JoinStateData<S, E>>();
            Collection<TransitionData<S, E>> transitions = stateMachineTransitions.getTransitions();
            for (TransitionData<S, E> tt : transitions) {
                if (tt.getSource() == s) {
                    StateHolder<S, E> holder = new StateHolder<S, E>(stateMap.get(tt.getTarget()));
                    if (holder.getState() == null) {
                        holderMap.put(tt.getTarget(), holder);
                    }
                    joinTargets.add(new JoinStateData<S, E>(holder, tt.getGuard()));
                }
            }
            JoinPseudoState<S, E> pseudoState = new JoinPseudoState<S, E>(joins, joinTargets);

            state = buildStateInternal(stateData.getState(), stateData.getDeferred(),
                    stateData.getEntryActions(), stateData.getExitActions(), stateData.getStateActions(),
                    pseudoState, stateMachineModel);
            states.add(state);
            stateMap.put(stateData.getState(), state);
        }
    }

    Collection<Transition<S, E>> transitions = new ArrayList<Transition<S, E>>();
    for (TransitionData<S, E> transitionData : transitionsData) {
        S source = transitionData.getSource();
        S target = transitionData.getTarget();
        E event = transitionData.getEvent();
        Long period = transitionData.getPeriod();
        Integer count = transitionData.getCount();

        Trigger<S, E> trigger = null;
        if (event != null) {
            trigger = new EventTrigger<S, E>(event);
        } else if (period != null) {
            TimerTrigger<S, E> t = new TimerTrigger<S, E>(period, count != null ? count : 0);
            if (beanFactory != null) {
                t.setBeanFactory(beanFactory);
            }
            if (taskExecutor != null) {
                t.setTaskExecutor(taskExecutor);
            }
            if (taskScheduler != null) {
                t.setTaskScheduler(taskScheduler);
            }
            trigger = t;
            ((AbstractState<S, E>) stateMap.get(source)).getTriggers().add(trigger);
        }

        if (transitionData.getKind() == TransitionKind.EXTERNAL) {
            // TODO can we do this?
            if (stateMap.get(source) == null || stateMap.get(target) == null) {
                continue;
            }
            DefaultExternalTransition<S, E> transition = new DefaultExternalTransition<S, E>(
                    stateMap.get(source), stateMap.get(target), transitionData.getActions(), event,
                    transitionData.getGuard(), trigger, transitionData.getSecurityRule());
            transitions.add(transition);

        } else if (transitionData.getKind() == TransitionKind.LOCAL) {
            // TODO can we do this?
            if (stateMap.get(source) == null || stateMap.get(target) == null) {
                continue;
            }
            DefaultLocalTransition<S, E> transition = new DefaultLocalTransition<S, E>(stateMap.get(source),
                    stateMap.get(target), transitionData.getActions(), event, transitionData.getGuard(),
                    trigger, transitionData.getSecurityRule());
            transitions.add(transition);
        } else if (transitionData.getKind() == TransitionKind.INTERNAL) {
            DefaultInternalTransition<S, E> transition = new DefaultInternalTransition<S, E>(
                    stateMap.get(source), transitionData.getActions(), event, transitionData.getGuard(),
                    trigger, transitionData.getSecurityRule());
            transitions.add(transition);
        }
    }

    if (stateMachineTransitions.getJoins() != null) {
        for (Entry<S, List<S>> entry : stateMachineTransitions.getJoins().entrySet()) {
            if (stateMap.get(entry.getKey()) != null) {
                List<S> entryList = entry.getValue();
                for (S entryState : entryList) {
                    State<S, E> source = stateMap.get(entryState);
                    if (source != null && !source.isOrthogonal()) {
                        State<S, E> target = stateMap.get(entry.getKey());
                        DefaultExternalTransition<S, E> transition = new DefaultExternalTransition<S, E>(source,
                                target, null, null, null, null, null);
                        transitions.add(transition);
                    }
                }
            }
        }
    }

    Transition<S, E> initialTransition = new InitialTransition<S, E>(initialState, initialAction);
    StateMachine<S, E> machine = buildStateMachineInternal(states, transitions, initialState, initialTransition,
            null, defaultExtendedState, historyState, contextEvents, beanFactory, taskExecutor, taskScheduler,
            beanName, machineId != null ? machineId : stateMachineModel.getConfigurationData().getMachineId(),
            uuid, stateMachineModel);
    return machine;
}

From source file:org.springframework.statemachine.EnumStateMachineTests.java

@Test
public void testSimpleStateSwitch() {
    PseudoState<TestStates, TestEvents> pseudoState = new DefaultPseudoState<TestStates, TestEvents>(
            PseudoStateKind.INITIAL);
    State<TestStates, TestEvents> stateSI = new EnumState<TestStates, TestEvents>(TestStates.SI, pseudoState);
    State<TestStates, TestEvents> stateS1 = new EnumState<TestStates, TestEvents>(TestStates.S1);
    State<TestStates, TestEvents> stateS2 = new EnumState<TestStates, TestEvents>(TestStates.S2);
    State<TestStates, TestEvents> stateS3 = new EnumState<TestStates, TestEvents>(TestStates.S3);

    Collection<State<TestStates, TestEvents>> states = new ArrayList<State<TestStates, TestEvents>>();
    states.add(stateSI);//from ww  w .  j a  v a 2s . c  o m
    states.add(stateS1);
    states.add(stateS2);
    states.add(stateS3);

    Collection<Transition<TestStates, TestEvents>> transitions = new ArrayList<Transition<TestStates, TestEvents>>();

    Collection<Action<TestStates, TestEvents>> actionsFromSIToS1 = new ArrayList<Action<TestStates, TestEvents>>();
    actionsFromSIToS1.add(new LoggingAction("actionsFromSIToS1"));
    DefaultExternalTransition<TestStates, TestEvents> transitionFromSIToS1 = new DefaultExternalTransition<TestStates, TestEvents>(
            stateSI, stateS1, actionsFromSIToS1, TestEvents.E1, null,
            new EventTrigger<TestStates, TestEvents>(TestEvents.E1));

    Collection<Action<TestStates, TestEvents>> actionsFromS1ToS2 = new ArrayList<Action<TestStates, TestEvents>>();
    actionsFromS1ToS2.add(new LoggingAction("actionsFromS1ToS2"));
    DefaultExternalTransition<TestStates, TestEvents> transitionFromS1ToS2 = new DefaultExternalTransition<TestStates, TestEvents>(
            stateS1, stateS2, actionsFromS1ToS2, TestEvents.E2, null,
            new EventTrigger<TestStates, TestEvents>(TestEvents.E2));

    Collection<Action<TestStates, TestEvents>> actionsFromS2ToS3 = new ArrayList<Action<TestStates, TestEvents>>();
    actionsFromS1ToS2.add(new LoggingAction("actionsFromS2ToS3"));
    DefaultExternalTransition<TestStates, TestEvents> transitionFromS2ToS3 = new DefaultExternalTransition<TestStates, TestEvents>(
            stateS2, stateS3, actionsFromS2ToS3, TestEvents.E3, null,
            new EventTrigger<TestStates, TestEvents>(TestEvents.E3));

    transitions.add(transitionFromSIToS1);
    transitions.add(transitionFromS1ToS2);
    transitions.add(transitionFromS2ToS3);

    SyncTaskExecutor taskExecutor = new SyncTaskExecutor();
    BeanFactory beanFactory = new DefaultListableBeanFactory();
    ObjectStateMachine<TestStates, TestEvents> machine = new ObjectStateMachine<TestStates, TestEvents>(states,
            transitions, stateSI);
    machine.setTaskExecutor(taskExecutor);
    machine.setBeanFactory(beanFactory);
    machine.afterPropertiesSet();
    machine.start();

    State<TestStates, TestEvents> initialState = machine.getInitialState();
    assertThat(initialState, is(stateSI));

    State<TestStates, TestEvents> state = machine.getState();
    assertThat(state, is(stateSI));

    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build());
    state = machine.getState();
    assertThat(state, is(stateS1));

    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E2).build());
    state = machine.getState();
    assertThat(state, is(stateS2));

    // not processed
    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build());
    state = machine.getState();
    assertThat(state, is(stateS2));

    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E3).build());
    state = machine.getState();
    assertThat(state, is(stateS3));
}

From source file:org.springframework.statemachine.EnumStateMachineTests.java

@Test
public void testDeferredEvents() {
    PseudoState<TestStates, TestEvents> pseudoState = new DefaultPseudoState<TestStates, TestEvents>(
            PseudoStateKind.INITIAL);

    Collection<TestEvents> deferred = new ArrayList<TestEvents>();
    deferred.add(TestEvents.E2);/*from   w  w w . ja va2 s .  c  om*/
    deferred.add(TestEvents.E3);

    // states
    State<TestStates, TestEvents> stateSI = new EnumState<TestStates, TestEvents>(TestStates.SI, deferred, null,
            null, pseudoState);
    State<TestStates, TestEvents> stateS1 = new EnumState<TestStates, TestEvents>(TestStates.S1);
    State<TestStates, TestEvents> stateS2 = new EnumState<TestStates, TestEvents>(TestStates.S2);
    State<TestStates, TestEvents> stateS3 = new EnumState<TestStates, TestEvents>(TestStates.S3);

    Collection<State<TestStates, TestEvents>> states = new ArrayList<State<TestStates, TestEvents>>();
    states.add(stateSI);
    states.add(stateS1);
    states.add(stateS2);
    states.add(stateS3);

    // transitions
    Collection<Transition<TestStates, TestEvents>> transitions = new ArrayList<Transition<TestStates, TestEvents>>();

    Collection<Action<TestStates, TestEvents>> actionsFromSIToS1 = new ArrayList<Action<TestStates, TestEvents>>();
    actionsFromSIToS1.add(new LoggingAction("actionsFromSIToS1"));
    DefaultExternalTransition<TestStates, TestEvents> transitionFromSIToS1 = new DefaultExternalTransition<TestStates, TestEvents>(
            stateSI, stateS1, actionsFromSIToS1, TestEvents.E1, null,
            new EventTrigger<TestStates, TestEvents>(TestEvents.E1));

    Collection<Action<TestStates, TestEvents>> actionsFromS1ToS2 = new ArrayList<Action<TestStates, TestEvents>>();
    actionsFromS1ToS2.add(new LoggingAction("actionsFromS1ToS2"));
    DefaultExternalTransition<TestStates, TestEvents> transitionFromS1ToS2 = new DefaultExternalTransition<TestStates, TestEvents>(
            stateS1, stateS2, actionsFromS1ToS2, TestEvents.E2, null,
            new EventTrigger<TestStates, TestEvents>(TestEvents.E2));

    Collection<Action<TestStates, TestEvents>> actionsFromS2ToS3 = new ArrayList<Action<TestStates, TestEvents>>();
    actionsFromS1ToS2.add(new LoggingAction("actionsFromS2ToS3"));
    DefaultExternalTransition<TestStates, TestEvents> transitionFromS2ToS3 = new DefaultExternalTransition<TestStates, TestEvents>(
            stateS2, stateS3, actionsFromS2ToS3, TestEvents.E3, null,
            new EventTrigger<TestStates, TestEvents>(TestEvents.E3));

    transitions.add(transitionFromSIToS1);
    transitions.add(transitionFromS1ToS2);
    transitions.add(transitionFromS2ToS3);

    // create machine
    SyncTaskExecutor taskExecutor = new SyncTaskExecutor();
    BeanFactory beanFactory = new DefaultListableBeanFactory();
    ObjectStateMachine<TestStates, TestEvents> machine = new ObjectStateMachine<TestStates, TestEvents>(states,
            transitions, stateSI);
    machine.setTaskExecutor(taskExecutor);
    machine.setBeanFactory(beanFactory);
    machine.afterPropertiesSet();
    machine.start();

    State<TestStates, TestEvents> initialState = machine.getInitialState();
    assertThat(initialState, is(stateSI));

    State<TestStates, TestEvents> state = machine.getState();
    assertThat(state, is(stateSI));

    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E2).build());
    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E3).build());
    state = machine.getState();
    assertThat(state, is(stateSI));

    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build());
    state = machine.getState();
    assertThat(state, is(stateS3));
}

From source file:org.springframework.statemachine.EnumStateMachineTests.java

@Test
public void testInternalTransitions() {
    PseudoState<TestStates, TestEvents> pseudoState = new DefaultPseudoState<TestStates, TestEvents>(
            PseudoStateKind.INITIAL);
    State<TestStates, TestEvents> stateSI = new EnumState<TestStates, TestEvents>(TestStates.SI, pseudoState);

    Collection<State<TestStates, TestEvents>> states = new ArrayList<State<TestStates, TestEvents>>();
    states.add(stateSI);// ww  w .  j  a va 2s .  co m

    Collection<Action<TestStates, TestEvents>> actionsInSI = new ArrayList<Action<TestStates, TestEvents>>();
    actionsInSI.add(new LoggingAction("actionsInSI"));
    DefaultInternalTransition<TestStates, TestEvents> transitionInternalSI = new DefaultInternalTransition<TestStates, TestEvents>(
            stateSI, actionsInSI, TestEvents.E1, null, new EventTrigger<TestStates, TestEvents>(TestEvents.E1));

    // transitions
    Collection<Transition<TestStates, TestEvents>> transitions = new ArrayList<Transition<TestStates, TestEvents>>();
    transitions.add(transitionInternalSI);

    SyncTaskExecutor taskExecutor = new SyncTaskExecutor();
    BeanFactory beanFactory = new DefaultListableBeanFactory();
    ObjectStateMachine<TestStates, TestEvents> machine = new ObjectStateMachine<TestStates, TestEvents>(states,
            transitions, stateSI);
    machine.setTaskExecutor(taskExecutor);
    machine.setBeanFactory(beanFactory);
    machine.afterPropertiesSet();
    machine.start();

    machine.sendEvent(MessageBuilder.withPayload(TestEvents.E1).build());
}

From source file:org.springframework.statemachine.support.AbstractStateMachine.java

@Override
protected void onInit() throws Exception {
    super.onInit();
    Assert.notNull(initialState, "Initial state must be set");
    Assert.state(/*from   w w  w  .java 2  s.c om*/
            initialState.getPseudoState() != null
                    && initialState.getPseudoState().getKind() == PseudoStateKind.INITIAL,
            "Initial state's pseudostate kind must be INITIAL");
    lastState = null;
    extendedState.setExtendedStateChangeListener(new ExtendedStateChangeListener() {
        @Override
        public void changed(Object key, Object value) {
            notifyExtendedStateChanged(key, value,
                    buildStateContext(Stage.EXTENDED_STATE_CHANGED, null, null, getRelayStateMachine()));
        }
    });

    // process given transitions
    for (Transition<S, E> transition : transitions) {
        Trigger<S, E> trigger = transition.getTrigger();
        if (trigger != null) {
            // we have same triggers with different transitions
            triggerToTransitionMap.put(trigger, transition);
        } else {
            triggerlessTransitions.add(transition);
        }
    }

    for (State<S, E> state : states) {
        if (state.isSubmachineState()) {
            StateMachine<S, E> submachine = ((AbstractState<S, E>) state).getSubmachine();
            submachine.addStateListener(new StateMachineListenerRelay());
        } else if (state.isOrthogonal()) {
            Collection<Region<S, E>> regions = ((AbstractState<S, E>) state).getRegions();
            for (Region<S, E> region : regions) {
                region.addStateListener(new StateMachineListenerRelay());
            }
        }
        if (state.getPseudoState() != null && (state.getPseudoState().getKind() == PseudoStateKind.HISTORY_DEEP
                || state.getPseudoState().getKind() == PseudoStateKind.HISTORY_DEEP)) {
            history = state.getPseudoState();
        }
    }

    DefaultStateMachineExecutor<S, E> executor = new DefaultStateMachineExecutor<S, E>(this,
            getRelayStateMachine(), transitions, triggerToTransitionMap, triggerlessTransitions,
            initialTransition, initialEvent);
    if (getBeanFactory() != null) {
        executor.setBeanFactory(getBeanFactory());
    }
    if (getTaskExecutor() != null) {
        executor.setTaskExecutor(getTaskExecutor());
    }
    executor.afterPropertiesSet();
    executor.setStateMachineExecutorTransit(new StateMachineExecutorTransit<S, E>() {

        @Override
        public void transit(Transition<S, E> t, StateContext<S, E> ctx, Message<E> message) {
            long now = System.currentTimeMillis();
            // TODO: fix above stateContext as it's not used
            notifyTransitionStart(
                    buildStateContext(Stage.TRANSITION_START, message, t, getRelayStateMachine()));
            notifyTransition(buildStateContext(Stage.TRANSITION, message, t, getRelayStateMachine()));
            if (t.getTarget().getPseudoState() != null
                    && t.getTarget().getPseudoState().getKind() == PseudoStateKind.JOIN) {
                exitFromState(t.getSource(), message, t, getRelayStateMachine());
            } else {
                if (t.getKind() == TransitionKind.INITIAL) {
                    switchToState(t.getTarget(), message, t, getRelayStateMachine());
                    notifyStateMachineStarted(
                            buildStateContext(Stage.STATEMACHINE_START, message, t, getRelayStateMachine()));
                } else if (t.getKind() != TransitionKind.INTERNAL) {
                    switchToState(t.getTarget(), message, t, getRelayStateMachine());
                }
            }
            // TODO: looks like events should be called here and anno processing earlier
            notifyTransitionEnd(buildStateContext(Stage.TRANSITION_END, message, t, getRelayStateMachine()));
            notifyTransitionMonitor(getRelayStateMachine(), t, System.currentTimeMillis() - now);
        }
    });
    stateMachineExecutor = executor;

    for (Transition<S, E> t : getTransitions()) {
        t.addActionListener(new ActionListener<S, E>() {

            @Override
            public void onExecute(StateMachine<S, E> stateMachine, Action<S, E> action, long duration) {
                notifyActionMonitor(stateMachine, action, duration);
            }
        });
    }
    for (State<S, E> s : getStates()) {
        s.addActionListener(new ActionListener<S, E>() {
            @Override
            public void onExecute(StateMachine<S, E> stateMachine, Action<S, E> action, long duration) {
                notifyActionMonitor(stateMachine, action, duration);
            }
        });
    }
}

From source file:org.springframework.statemachine.support.AbstractStateMachine.java

private void switchToState(State<S, E> state, Message<E> message, Transition<S, E> transition,
        StateMachine<S, E> stateMachine) {
    if (!isInitialTransition(transition) && !StateMachineUtils.isTransientPseudoState(state)
            && !callPreStateChangeInterceptors(state, message, transition, stateMachine)) {
        return;/*from  w w w.ja  v a  2 s  .co m*/
    }

    StateContext<S, E> stateContext = buildStateContext(Stage.STATE_CHANGED, message, transition, stateMachine);
    State<S, E> toState = followLinkedPseudoStates(state, stateContext);
    PseudoStateKind kind = state.getPseudoState() != null ? state.getPseudoState().getKind() : null;
    if (kind != null && (kind != PseudoStateKind.INITIAL && kind != PseudoStateKind.JOIN
            && kind != PseudoStateKind.FORK)) {
        callPreStateChangeInterceptors(toState, message, transition, stateMachine);
    }

    // need to check for from original state passed in
    kind = toState.getPseudoState() != null ? toState.getPseudoState().getKind() : null;
    if (kind == PseudoStateKind.FORK) {
        exitCurrentState(toState, message, transition, stateMachine);
        ForkPseudoState<S, E> fps = (ForkPseudoState<S, E>) toState.getPseudoState();
        for (State<S, E> ss : fps.getForks()) {
            callPreStateChangeInterceptors(ss, message, transition, stateMachine);
            setCurrentState(ss, message, transition, false, stateMachine, null, fps.getForks());
        }
    } else {
        Collection<State<S, E>> targets = new ArrayList<>();
        targets.add(toState);
        setCurrentState(toState, message, transition, true, stateMachine, null, targets);
    }

    callPostStateChangeInterceptors(state, message, transition, stateMachine);

    stateMachineExecutor.execute();
    if (isComplete()) {
        stop();
    }
}

From source file:org.springframework.statemachine.support.AbstractStateMachine.java

private State<S, E> followLinkedPseudoStates(State<S, E> state, StateContext<S, E> stateContext) {
    PseudoStateKind kind = state.getPseudoState() != null ? state.getPseudoState().getKind() : null;
    if (kind == PseudoStateKind.INITIAL || kind == PseudoStateKind.FORK) {
        return state;
    } else if (kind != null) {
        State<S, E> toState = state.getPseudoState().entry(stateContext);
        if (toState == null) {
            return state;
        } else {//from  www  .ja  v  a  2 s. c o m
            return followLinkedPseudoStates(toState, stateContext);
        }
    } else {
        return state;
    }
}

From source file:org.springframework.statemachine.support.AbstractStateMachine.java

private static <S, E> boolean isInitial(State<S, E> state) {
    return state.getPseudoState() != null && state.getPseudoState().getKind() == PseudoStateKind.INITIAL;
}