Java Code Examples for org.apache.flink.cep.pattern.Quantifier.ConsumingStrategy#STRICT

/**
 * Starts a new pattern sequence. The provided pattern is the initial pattern
 * of the new sequence.
 *
 *
 * @param group the pattern to begin with
 * @param afterMatchSkipStrategy the {@link AfterMatchSkipStrategy.SkipStrategy} to use after each match.
 * @return The first pattern of a pattern sequence
 */
public static <T, F extends T> GroupPattern<T, F> begin(final Pattern<T, F> group, final AfterMatchSkipStrategy afterMatchSkipStrategy) {
	return new GroupPattern<>(null, group, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Appends a new group pattern to the existing one. The new pattern enforces strict
 * temporal contiguity. This means that the whole pattern sequence matches only
 * if an event which matches this pattern directly follows the preceding matching
 * event. Thus, there cannot be any events in between two matching events.
 *
 * @param group the pattern to append
 * @return A new pattern which is appended to this one
 */
public GroupPattern<T, F> next(Pattern<T, F> group) {
	return new GroupPattern<>(this, group, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided pattern is the initial pattern
 * of the new sequence.
 *
 * @param group the pattern to begin with
 * @return the first pattern of a pattern sequence
 */
public static <T, F extends T> GroupPattern<T, F> begin(Pattern<T, F> group) {
	return new GroupPattern<>(null, group, ConsumingStrategy.STRICT, AfterMatchSkipStrategy.noSkip());
}
 

/**
 * Starts a new pattern sequence. The provided pattern is the initial pattern
 * of the new sequence.
 *
 *
 * @param group the pattern to begin with
 * @param afterMatchSkipStrategy the {@link AfterMatchSkipStrategy.SkipStrategy} to use after each match.
 * @return The first pattern of a pattern sequence
 */
public static <T, F extends T> GroupPattern<T, F> begin(final Pattern<T, F> group, final AfterMatchSkipStrategy afterMatchSkipStrategy) {
	return new GroupPattern<>(null, group, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Appends a new pattern to the existing one. The new pattern enforces strict
 * temporal contiguity. This means that the whole pattern sequence matches only
 * if an event which matches this pattern directly follows the preceding matching
 * event. Thus, there cannot be any events in between two matching events.
 *
 * @param name Name of the new pattern
 * @return A new pattern which is appended to this one
 */
public Pattern<T, T> next(final String name) {
	return new Pattern<>(name, this, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided name is the one of the initial pattern
 * of the new sequence. Furthermore, the base type of the event sequence is set.
 *
 * @param name The name of starting pattern of the new pattern sequence
 * @param afterMatchSkipStrategy the {@link AfterMatchSkipStrategy.SkipStrategy} to use after each match.
 * @param <X> Base type of the event pattern
 * @return The first pattern of a pattern sequence
 */
public static <X> Pattern<X, X> begin(final String name, final AfterMatchSkipStrategy afterMatchSkipStrategy) {
	return new Pattern<X, X>(name, null, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided name is the one of the initial pattern
 * of the new sequence. Furthermore, the base type of the event sequence is set.
 *
 * @param name The name of starting pattern of the new pattern sequence
 * @param <X> Base type of the event pattern
 * @return The first pattern of a pattern sequence
 */
public static <X> Pattern<X, X> begin(final String name) {
	return new Pattern<>(name, null, ConsumingStrategy.STRICT, AfterMatchSkipStrategy.noSkip());
}
 

/**
 * Appends a new group pattern to the existing one. The new pattern enforces strict
 * temporal contiguity. This means that the whole pattern sequence matches only
 * if an event which matches this pattern directly follows the preceding matching
 * event. Thus, there cannot be any events in between two matching events.
 *
 * @param group the pattern to append
 * @return A new pattern which is appended to this one
 */
public GroupPattern<T, F> next(Pattern<T, F> group) {
	return new GroupPattern<>(this, group, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided pattern is the initial pattern
 * of the new sequence.
 *
 * @param group the pattern to begin with
 * @return the first pattern of a pattern sequence
 */
public static <T, F extends T> GroupPattern<T, F> begin(Pattern<T, F> group) {
	return new GroupPattern<>(null, group, ConsumingStrategy.STRICT, AfterMatchSkipStrategy.noSkip());
}
 

/**
 * Starts a new pattern sequence. The provided name is the one of the initial pattern
 * of the new sequence. Furthermore, the base type of the event sequence is set.
 *
 * @param name The name of starting pattern of the new pattern sequence
 * @param <X> Base type of the event pattern
 * @return The first pattern of a pattern sequence
 */
public static <X> Pattern<X, X> begin(final String name) {
	return new Pattern<>(name, null, ConsumingStrategy.STRICT, AfterMatchSkipStrategy.noSkip());
}
 

/**
 * Appends a new pattern to the existing one. The new pattern enforces strict
 * temporal contiguity. This means that the whole pattern sequence matches only
 * if an event which matches this pattern directly follows the preceding matching
 * event. Thus, there cannot be any events in between two matching events.
 *
 * @param name Name of the new pattern
 * @return A new pattern which is appended to this one
 */
public Pattern<T, T> next(final String name) {
	return new Pattern<>(name, this, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided name is the one of the initial pattern
 * of the new sequence. Furthermore, the base type of the event sequence is set.
 *
 * @param name The name of starting pattern of the new pattern sequence
 * @param afterMatchSkipStrategy the {@link AfterMatchSkipStrategy.SkipStrategy} to use after each match.
 * @param <X> Base type of the event pattern
 * @return The first pattern of a pattern sequence
 */
public static <X> Pattern<X, X> begin(final String name, final AfterMatchSkipStrategy afterMatchSkipStrategy) {
	return new Pattern<X, X>(name, null, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided name is the one of the initial pattern
 * of the new sequence. Furthermore, the base type of the event sequence is set.
 *
 * @param name The name of starting pattern of the new pattern sequence
 * @param <X> Base type of the event pattern
 * @return The first pattern of a pattern sequence
 */
public static <X> Pattern<X, X> begin(final String name) {
	return new Pattern<>(name, null, ConsumingStrategy.STRICT, AfterMatchSkipStrategy.noSkip());
}
 

/**
 * Appends a new group pattern to the existing one. The new pattern enforces strict
 * temporal contiguity. This means that the whole pattern sequence matches only
 * if an event which matches this pattern directly follows the preceding matching
 * event. Thus, there cannot be any events in between two matching events.
 *
 * @param group the pattern to append
 * @return A new pattern which is appended to this one
 */
public GroupPattern<T, F> next(Pattern<T, F> group) {
	return new GroupPattern<>(this, group, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided pattern is the initial pattern
 * of the new sequence.
 *
 * @param group the pattern to begin with
 * @return the first pattern of a pattern sequence
 */
public static <T, F extends T> GroupPattern<T, F> begin(Pattern<T, F> group) {
	return new GroupPattern<>(null, group, ConsumingStrategy.STRICT, AfterMatchSkipStrategy.noSkip());
}
 

/**
 * Starts a new pattern sequence. The provided pattern is the initial pattern
 * of the new sequence.
 *
 *
 * @param group the pattern to begin with
 * @param afterMatchSkipStrategy the {@link AfterMatchSkipStrategy.SkipStrategy} to use after each match.
 * @return The first pattern of a pattern sequence
 */
public static <T, F extends T> GroupPattern<T, F> begin(final Pattern<T, F> group, final AfterMatchSkipStrategy afterMatchSkipStrategy) {
	return new GroupPattern<>(null, group, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Appends a new pattern to the existing one. The new pattern enforces strict
 * temporal contiguity. This means that the whole pattern sequence matches only
 * if an event which matches this pattern directly follows the preceding matching
 * event. Thus, there cannot be any events in between two matching events.
 *
 * @param name Name of the new pattern
 * @return A new pattern which is appended to this one
 */
public Pattern<T, T> next(final String name) {
	return new Pattern<>(name, this, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}
 

/**
 * Starts a new pattern sequence. The provided name is the one of the initial pattern
 * of the new sequence. Furthermore, the base type of the event sequence is set.
 *
 * @param name The name of starting pattern of the new pattern sequence
 * @param afterMatchSkipStrategy the {@link AfterMatchSkipStrategy.SkipStrategy} to use after each match.
 * @param <X> Base type of the event pattern
 * @return The first pattern of a pattern sequence
 */
public static <X> Pattern<X, X> begin(final String name, final AfterMatchSkipStrategy afterMatchSkipStrategy) {
	return new Pattern<X, X>(name, null, ConsumingStrategy.STRICT, afterMatchSkipStrategy);
}