private void addTransition(String pattern, State next) { tos.put(next.getName(), next); transitions.add(StateTransition.createStateTransition(currentState, pattern, next.getName())); if (transitions.size() == 1) { transitions.add(StateTransition.createEndStateTransition(failedState)); transitions.add(StateTransition.createEndStateTransition(completedState)); transitions.add(StateTransition.createEndStateTransition(stoppedState)); } if (next.isEndState()) { transitions.add(StateTransition.createEndStateTransition(next)); } dirty = true; }
/** * Create a new {@link StateTransition} specification from one {@link State} * to another (by name). * * @param state the {@link State} used to generate the outcome for this * transition * @param pattern the pattern to match in the exit status of the * {@link State} (can be {@code null}) * @param next the name of the next {@link State} to execute (can be {@code null}) * @return {@link StateTransition} that was created. */ public static StateTransition createStateTransition(State state, @Nullable String pattern, @Nullable String next) { return new StateTransition(state, pattern, next); }
@Override public SimpleFlow getObject() throws Exception { SimpleFlow flow = flowType.getConstructor(String.class).newInstance(name); flow.setStateTransitionComparator(stateTransitionComparator); List<StateTransition> updatedTransitions = new ArrayList<>(); for (StateTransition stateTransition : stateTransitions) { State state = getProxyState(stateTransition.getState()); updatedTransitions.add(StateTransition.switchOriginAndDestination(stateTransition, state, getNext(stateTransition.getNext()))); } flow.setStateTransitions(updatedTransitions); flow.afterPropertiesSet(); return flow; }
@Test public void testMatchesStar() { StateTransition transition = StateTransition.createStateTransition(state, "*", "start"); assertTrue(transition.matches("CONTINUABLE")); }
@Test public void testIsEnd() { StateTransition transition = StateTransition.createEndStateTransition(state, ""); assertTrue(transition.isEnd()); assertNull(transition.getNext()); }
/** * Create a new end state {@link StateTransition} specification. This * transition explicitly goes unconditionally to an end state (i.e. no more * executions). * * @param state the {@link State} used to generate the outcome for this * transition * @return {@link StateTransition} that was created. */ public static StateTransition createEndStateTransition(State state) { return createStateTransition(state, null, null); }
@Test public void testGetStateDoesNotExist() throws Exception { flow.setStateTransitions(Collections.singletonList(StateTransition.createEndStateTransition(new StubState( "step1")))); flow.afterPropertiesSet(); State state = flow.getState("bar"); assertNull(state); }
private void addDanglingEndStates() { Set<String> froms = new HashSet<>(); for (StateTransition transition : transitions) { froms.add(transition.getState().getName());
@Test public void testToString() { StateTransition transition = StateTransition.createStateTransition(state, "CONTIN???LE", "start"); String string = transition.toString(); assertTrue("Wrong string: " + string, string.contains("Transition")); assertTrue("Wrong string: " + string, string.contains("start")); assertTrue("Wrong string: " + string, string.contains("CONTIN???LE")); assertTrue("Wrong string: " + string, string.contains("next=")); }
@Override public int compare(StateTransition arg0, StateTransition arg1) { String value = arg1.getPattern(); if (arg0.getPattern().equals(value)) { return 0; } int patternCount = StringUtils.countOccurrencesOf(arg0.getPattern(), "*"); int valueCount = StringUtils.countOccurrencesOf(value, "*"); if (patternCount > valueCount) { return 1; } if (patternCount < valueCount) { return -1; } patternCount = StringUtils.countOccurrencesOf(arg0.getPattern(), "?"); valueCount = StringUtils.countOccurrencesOf(value, "?"); if (patternCount > valueCount) { return 1; } if (patternCount < valueCount) { return -1; } return arg0.getPattern().compareTo(value); } }
public Object getObject() throws Exception { SimpleFlow flow = new SimpleFlow(name); List<StateTransition> updatedTransitions = new ArrayList<StateTransition>(); for (StateTransition stateTransition : stateTransitions) { State state = getProxyState(stateTransition.getState()); updatedTransitions.add(StateTransition.switchOriginAndDestination(stateTransition, state, getNext(stateTransition.getNext()))); } flow.setStateTransitions(updatedTransitions); flow.afterPropertiesSet(); return flow; }
@Test public void testMatchesNull() { StateTransition transition = StateTransition.createStateTransition(state, null, "start"); assertTrue(transition.matches("CONTINUABLE")); }
/** * Create a new state {@link StateTransition} specification with a wildcard * pattern that matches all outcomes. * * @param state the {@link State} used to generate the outcome for this * transition * @param next the name of the next {@link State} to execute * @return {@link StateTransition} that was created. */ public static StateTransition createStateTransition(State state, String next) { return createStateTransition(state, null, next); }
@Test public void testUnconnectedSteps() throws Exception { flow.setStateTransitions(collect(StateTransition.createEndStateTransition(new StubState("step1")), StateTransition.createEndStateTransition(new StubState("step2")))); flow.afterPropertiesSet(); FlowExecution execution = flow.start(executor); assertEquals(FlowExecutionStatus.COMPLETED, execution.getStatus()); assertEquals("step1", execution.getName()); }
private void addDanglingEndStates() { Set<String> froms = new HashSet<String>(); for (StateTransition transition : transitions) { froms.add(transition.getState().getName());