Example usage for org.springframework.statemachine.transition Transition getTrigger

Introduction

In this page you can find the example usage for org.springframework.statemachine.transition Transition getTrigger.

Prototype

Trigger<S, E> getTrigger();

Source Link

Document

Gets the transition trigger.

Usage

From source file:gov.grantsolutions.REST.StateMachineController.java

@RequestMapping(value = "/commitment/availableEvents/{currentState}", method = RequestMethod.GET)
public @ResponseBody List<String> availableCommitmentEvents(@PathVariable final String currentState) {
    List<String> list = new ArrayList<String>();
    if (!StringUtils.isEmpty(currentState)) {
        Iterator<Transition<String, String>> transitions = commitmentState.getTransitions().iterator();
        while (transitions.hasNext()) {
            Transition<String, String> transition = transitions.next();
            if (currentState.equalsIgnoreCase(transition.getSource().getId())) {
                list.add(transition.getTrigger().getEvent());
            }//w  w w.j av  a 2s. c om
        }
    }
    return list;
}

---

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(/* ww w.  ja  va 2s  . c o m*/
            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

protected synchronized boolean acceptEvent(Message<E> message) {
    if ((currentState != null && currentState.shouldDefer(message))) {
        log.info("Current state " + currentState + " deferred event " + message);
        stateMachineExecutor.queueDeferredEvent(message);
        return true;
    }/*from www  . j a  v a  2 s.  co m*/
    if ((currentState != null && currentState.sendEvent(message))) {
        return true;
    }

    if (log.isDebugEnabled()) {
        log.debug("Queue event " + message + " " + this);
    }

    for (Transition<S, E> transition : transitions) {
        State<S, E> source = transition.getSource();
        Trigger<S, E> trigger = transition.getTrigger();

        if (StateMachineUtils.containsAtleastOne(source.getIds(), currentState.getIds())) {
            if (trigger != null && trigger.evaluate(new DefaultTriggerContext<S, E>(message.getPayload()))) {
                stateMachineExecutor.queueEvent(message);
                return true;
            }
        }
    }
    // if we're about to not accept event, check defer again in case
    // state was changed between original check and now
    if ((currentState != null && currentState.shouldDefer(message))) {
        log.info("Current state " + currentState + " deferred event " + message);
        stateMachineExecutor.queueDeferredEvent(message);
        return true;
    }
    return false;
}

---

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

private boolean processEventQueue() {
    if (log.isDebugEnabled()) {
        log.debug("Process event queue, size=" + eventQueue.size());
    }/*w  ww  .ja  v  a 2s  . co  m*/
    Message<E> queuedEvent = eventQueue.poll();
    State<S, E> currentState = stateMachine.getState();
    if (queuedEvent != null) {
        if ((currentState != null && currentState.shouldDefer(queuedEvent))) {
            log.info("Current state " + currentState + " deferred event " + queuedEvent);
            queueDeferredEvent(queuedEvent);
            return true;
        }
        for (Transition<S, E> transition : transitions) {
            State<S, E> source = transition.getSource();
            Trigger<S, E> trigger = transition.getTrigger();

            if (StateMachineUtils.containsAtleastOne(source.getIds(), currentState.getIds())) {
                if (trigger != null
                        && trigger.evaluate(new DefaultTriggerContext<S, E>(queuedEvent.getPayload()))) {
                    queueTrigger(trigger, queuedEvent);
                    return true;
                }
            }
        }
    }
    return false;
}

---

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

private synchronized boolean processDeferList() {
    if (log.isDebugEnabled()) {
        log.debug("Process defer list, size=" + deferList.size());
    }/*  w  w  w  .  ja  v a2 s. com*/
    ListIterator<Message<E>> iterator = deferList.listIterator();
    State<S, E> currentState = stateMachine.getState();
    while (iterator.hasNext()) {
        Message<E> event = iterator.next();
        if (currentState.shouldDefer(event)) {
            // if current state still defers, just continue with others
            continue;
        }
        for (Transition<S, E> transition : transitions) {
            State<S, E> source = transition.getSource();
            Trigger<S, E> trigger = transition.getTrigger();
            if (source.equals(currentState)) {
                if (trigger != null && trigger.evaluate(new DefaultTriggerContext<S, E>(event.getPayload()))) {
                    triggerQueue.add(new TriggerQueueItem(trigger, event));
                    iterator.remove();
                    // bail out when first deferred message is causing a trigger to fire
                    return true;
                }
            }
        }
    }
    return false;
}

---