How to use

StateTransition

in

org.springframework.batch.core.job.flow.support

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;
}

if (stateTransition.matches(exitCode) || (exitCode.equals("PENDING") && stateTransition.matches("STOPPED"))) {
  if (stateTransition.isEnd()) {
  next = stateTransition.getNext();
  break;

/**
 * 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);
}

private boolean matches(String from, String status) {
  for (StateTransition transition : transitions) {
    if (from.equals(transition.getState().getName()) && transition.matches(status)) {
      return true;
    }
  }
  return false;
}

@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;
}

  State state = stateTransition.getState();
  String stateName = state.getName();
  stateMap.put(stateName, state);
  State state = stateTransition.getState();
  if (!stateTransition.isEnd()) {
    String next = stateTransition.getNext();
startState = stateTransitions.get(0).getState();

@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);
  }
}

  State state = stateTransition.getState();
  String stateName = state.getName();
  stateMap.put(stateName, state);
  State state = stateTransition.getState();
  if (!stateTransition.isEnd()) {
    String next = stateTransition.getNext();
startState = stateTransitions.get(0).getState();

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"));
}

private boolean matches(String from, String status) {
  for (StateTransition transition : transitions) {
    if (from.equals(transition.getState().getName()) && transition.matches(status)) {
      return true;
    }
  }
  return false;
}

/**
 * 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());