Github user dawidwys commented on a diff in the pull request:

    https://github.com/apache/flink/pull/4041#discussion_r119611549
  
    --- Diff: docs/dev/libs/cep.md ---
    @@ -246,63 +333,118 @@ pattern.where(event => ... /* some condition 
*/).or(event => ... /* or condition
     </div>
     </div>
     
    -Next, we can append further states to detect complex patterns.
    -We can control the contiguity of two succeeding events to be accepted by 
the pattern.
    +##### Conditions on Contiguity
     
    -Strict contiguity means that two matching events have to be directly the 
one after the other.
    -This means that no other events can occur in between. 
    -A strict contiguity pattern state can be created via the `next` method.
    +FlinkCEP supports the following forms of contiguity between consecutive 
events:
     
    -<div class="codetabs" markdown="1">
    -<div data-lang="java" markdown="1">
    -{% highlight java %}
    -Pattern<Event, ?> strictNext = start.next("middle");
    -{% endhighlight %}
    -</div>
    + 1. Strict Contiguity: which expects all matching events to appear 
strictly the one after the other,
    + without any non-matching events in-between.
     
    -<div data-lang="scala" markdown="1">
    -{% highlight scala %}
    -val strictNext: Pattern[Event, _] = start.next("middle")
    -{% endhighlight %}
    -</div>
    -</div>
    + 2. Relaxed Contiguity: which simply ignores non-matching events appearing 
in-between the matching ones.
    + 
    + 3. Non-Deterministic Relaxed Contiguity: which further relaxes contiguity 
by also creating alternative
    + matches which ignore also matching events.
     
    -Non-strict contiguity means that other events are allowed to occur 
in-between two matching events.
    -A non-strict contiguity pattern state can be created via the `followedBy` 
or `followedByAny` method.
    +To illustrate the above with an example, a pattern sequence `a+ b` (one or 
more `a`s followed by a `b`) with 
    +input `a1, c, a2, b` will have the following results:
    +
    + 1. Strict Contiguity: `a2 b` because there is `c` `a1` and `a2` so `a1` 
is discarded.
    --- End diff --
    
    there is `c` between `a1` and `a2`


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at [email protected] or file a JIRA ticket
with INFRA.
---

Reply via email to