How to use

addProceed

method

in

org.apache.flink.cep.nfa.State

private void addStopStates(final State<T> state) {
  for (Tuple2<IterativeCondition<T>, String> notCondition: getCurrentNotCondition()) {
    final State<T> stopState = createStopState(notCondition.f0, notCondition.f1);
    state.addProceed(stopState, notCondition.f0);
  }
}

/**
 * Create the states for the group pattern as a looping one.
 *
 * @param groupPattern the group pattern to create the states for
 * @param sinkState the state that the group pattern being converted should point to
 * @return the first state of the states of the group pattern
 */
private State<T> createLoopingGroupPatternState(
  final GroupPattern<T, ?> groupPattern,
  final State<T> sinkState) {
  final IterativeCondition<T> proceedCondition = getTrueFunction();
  Pattern<T, ?> oldCurrentPattern = currentPattern;
  Pattern<T, ?> oldFollowingPattern = followingPattern;
  GroupPattern<T, ?> oldGroupPattern = currentGroupPattern;
  final State<T> dummyState = createState(currentPattern.getName(), State.StateType.Normal);
  State<T> lastSink = dummyState;
  currentGroupPattern = groupPattern;
  currentPattern = groupPattern.getRawPattern();
  lastSink = createMiddleStates(lastSink);
  lastSink = convertPattern(lastSink);
  lastSink.addProceed(sinkState, proceedCondition);
  dummyState.addProceed(lastSink, proceedCondition);
  currentPattern = oldCurrentPattern;
  followingPattern = oldFollowingPattern;
  currentGroupPattern = oldGroupPattern;
  return lastSink;
}

private void addStopStateToLooping(final State<T> loopingState) {
  if (followingPattern != null &&
      followingPattern.getQuantifier().getConsumingStrategy() == Quantifier.ConsumingStrategy.NOT_FOLLOW) {
    final IterativeCondition<T> notCondition = getTakeCondition(followingPattern);
    final State<T> stopState = createStopState(notCondition, followingPattern.getName());
    loopingState.addProceed(stopState, notCondition);
  }
}

lastSink.addProceed(proceedState, proceedCondition);

    (IterativeCondition<T>) currentPattern.getUntilCondition();
  if (untilCondition != null) {
    singletonState.addProceed(
      originalStateMap.get(proceedState.getName()),
      new RichAndCondition<>(proceedCondition, untilCondition));
  singletonState.addProceed(proceedState,
    untilCondition != null
      ? new RichAndCondition<>(proceedCondition, new RichNotCondition<>(untilCondition))
      : proceedCondition);
} else {
  singletonState.addProceed(proceedState, proceedCondition);

  if (untilCondition != null) {
    State<T> sinkStateCopy = copy(sinkState);
    loopingState.addProceed(sinkStateCopy, new RichAndCondition<>(proceedCondition, untilCondition));
    originalStateMap.put(sinkState.getName(), sinkStateCopy);
  loopingState.addProceed(sinkState,
    untilCondition != null
      ? new RichAndCondition<>(proceedCondition, new RichNotCondition<>(untilCondition))
  updateWithGreedyCondition(sinkState, getTakeCondition(currentPattern));
} else {
  loopingState.addProceed(sinkState, proceedCondition);

    notNext.addProceed(lastSink, new RichNotCondition<>(notCondition));
  notNext.addProceed(stopState, notCondition);
  lastSink = notNext;
} else {

private void addStopStates(final State<T> state) {
  for (Tuple2<IterativeCondition<T>, String> notCondition: getCurrentNotCondition()) {
    final State<T> stopState = createStopState(notCondition.f0, notCondition.f1);
    state.addProceed(stopState, notCondition.f0);
  }
}

private void addStopStates(final State<T> state) {
  for (Tuple2<IterativeCondition<T>, String> notCondition: getCurrentNotCondition()) {
    final State<T> stopState = createStopState(notCondition.f0, notCondition.f1);
    state.addProceed(stopState, notCondition.f0);
  }
}

private void addStopStates(final State<T> state) {
  for (Tuple2<IterativeCondition<T>, String> notCondition: getCurrentNotCondition()) {
    final State<T> stopState = createStopState(notCondition.f0, notCondition.f1);
    state.addProceed(stopState, notCondition.f0);
  }
}

/**
 * Create the states for the group pattern as a looping one.
 *
 * @param groupPattern the group pattern to create the states for
 * @param sinkState the state that the group pattern being converted should point to
 * @return the first state of the states of the group pattern
 */
private State<T> createLoopingGroupPatternState(
  final GroupPattern<T, ?> groupPattern,
  final State<T> sinkState) {
  final IterativeCondition<T> proceedCondition = getTrueFunction();
  Pattern<T, ?> oldCurrentPattern = currentPattern;
  Pattern<T, ?> oldFollowingPattern = followingPattern;
  GroupPattern<T, ?> oldGroupPattern = currentGroupPattern;
  final State<T> dummyState = createState(currentPattern.getName(), State.StateType.Normal);
  State<T> lastSink = dummyState;
  currentGroupPattern = groupPattern;
  currentPattern = groupPattern.getRawPattern();
  lastSink = createMiddleStates(lastSink);
  lastSink = convertPattern(lastSink);
  lastSink.addProceed(sinkState, proceedCondition);
  dummyState.addProceed(lastSink, proceedCondition);
  currentPattern = oldCurrentPattern;
  followingPattern = oldFollowingPattern;
  currentGroupPattern = oldGroupPattern;
  return lastSink;
}

/**
 * Create the states for the group pattern as a looping one.
 *
 * @param groupPattern the group pattern to create the states for
 * @param sinkState the state that the group pattern being converted should point to
 * @return the first state of the states of the group pattern
 */
private State<T> createLoopingGroupPatternState(
  final GroupPattern<T, ?> groupPattern,
  final State<T> sinkState) {
  final IterativeCondition<T> proceedCondition = getTrueFunction();
  Pattern<T, ?> oldCurrentPattern = currentPattern;
  Pattern<T, ?> oldFollowingPattern = followingPattern;
  GroupPattern<T, ?> oldGroupPattern = currentGroupPattern;
  final State<T> dummyState = createState(currentPattern.getName(), State.StateType.Normal);
  State<T> lastSink = dummyState;
  currentGroupPattern = groupPattern;
  currentPattern = groupPattern.getRawPattern();
  lastSink = createMiddleStates(lastSink);
  lastSink = convertPattern(lastSink);
  lastSink.addProceed(sinkState, proceedCondition);
  dummyState.addProceed(lastSink, proceedCondition);
  currentPattern = oldCurrentPattern;
  followingPattern = oldFollowingPattern;
  currentGroupPattern = oldGroupPattern;
  return lastSink;
}

private void addStopStateToLooping(final State<T> loopingState) {
  if (followingPattern != null &&
      followingPattern.getQuantifier().getConsumingStrategy() == Quantifier.ConsumingStrategy.NOT_FOLLOW) {
    final IterativeCondition<T> notCondition = getTakeCondition(followingPattern);
    final State<T> stopState = createStopState(notCondition, followingPattern.getName());
    loopingState.addProceed(stopState, notCondition);
  }
}

private void addStopStateToLooping(final State<T> loopingState) {
  if (followingPattern != null &&
      followingPattern.getQuantifier().getConsumingStrategy() == Quantifier.ConsumingStrategy.NOT_FOLLOW) {
    final IterativeCondition<T> notCondition = (IterativeCondition<T>) followingPattern.getCondition();
    final State<T> stopState = createStopState(notCondition, followingPattern.getName());
    loopingState.addProceed(stopState, notCondition);
  }
}

private void addStopStateToLooping(final State<T> loopingState) {
  if (followingPattern != null &&
      followingPattern.getQuantifier().getConsumingStrategy() == Quantifier.ConsumingStrategy.NOT_FOLLOW) {
    final IterativeCondition<T> notCondition = getTakeCondition(followingPattern);
    final State<T> stopState = createStopState(notCondition, followingPattern.getName());
    loopingState.addProceed(stopState, notCondition);
  }
}

lastSink.addProceed(proceedState, proceedCondition);

/**
 * Creates a pair of states that enables relaxed strictness before a zeroOrMore looping state.
 *
 * @param loopingState the first state of zeroOrMore complex state
 * @param lastSink     the state that the looping one points to
 * @return the newly created state
 */
@SuppressWarnings("unchecked")
private State<T> createInitOptionalStateOfZeroOrMore(final State<T> loopingState, final State<T> lastSink) {
  final IterativeCondition<T> currentCondition = (IterativeCondition<T>) currentPattern.getCondition();
  final State<T> firstState = createState(currentPattern.getName(), State.StateType.Normal);
  firstState.addProceed(lastSink, BooleanConditions.<T>trueFunction());
  firstState.addTake(loopingState, currentCondition);
  final IterativeCondition<T> ignoreFunction = getIgnoreCondition(currentPattern);
  if (ignoreFunction != null) {
    final State<T> firstStateWithoutProceed = createState(currentPattern.getName(), State.StateType.Normal);
    firstState.addIgnore(firstStateWithoutProceed, ignoreFunction);
    firstStateWithoutProceed.addIgnore(ignoreFunction);
    firstStateWithoutProceed.addTake(loopingState, currentCondition);
    addStopStates(firstStateWithoutProceed);
  }
  return firstState;
}

singletonState.addProceed(sinkState, trueFunction);

/**
 * Creates the given state as a looping one. Looping state is one with TAKE edge to itself and
 * PROCEED edge to the sinkState. It also consists of a similar state without the PROCEED edge, so that
 * for each PROCEED transition branches in computation state graph  can be created only once.
 *
 * @param sinkState the state that the converted state should point to
 * @return the first state of the created complex state
 */
@SuppressWarnings("unchecked")
private State<T> createLooping(final State<T> sinkState) {
  final IterativeCondition<T> currentCondition = (IterativeCondition<T>) currentPattern.getCondition();
  final IterativeCondition<T> ignoreCondition = getInnerIgnoreCondition(currentPattern);
  final IterativeCondition<T> trueFunction = BooleanConditions.trueFunction();
  final State<T> loopingState = createState(currentPattern.getName(), State.StateType.Normal);
  loopingState.addProceed(sinkState, trueFunction);
  loopingState.addTake(currentCondition);
  addStopStateToLooping(loopingState);
  if (ignoreCondition != null) {
    final State<T> ignoreState = createState(currentPattern.getName(), State.StateType.Normal);
    ignoreState.addTake(loopingState, currentCondition);
    ignoreState.addIgnore(ignoreCondition);
    loopingState.addIgnore(ignoreState, ignoreCondition);
    addStopStateToLooping(ignoreState);
  }
  return loopingState;
}

singletonState.addProceed(sinkState, BooleanConditions.<T>trueFunction());