Skip to content

Commit

Permalink
[hotfix][docs-zh] Fix the formatting errors of some Chinese documents.
Browse files Browse the repository at this point in the history
  • Loading branch information
@liuzhuang2017 @MartijnVisser
liuzhuang2017 authored and MartijnVisser committed May 25, 2022
1 parent ffca99d commit b51084d
Showing 1 changed file with 139 additions and 198 deletions.
337 changes: 139 additions & 198 deletions docs/content.zh/docs/libs/cep.md
View file
Expand Up @@ -388,21 +388,12 @@ pattern.where(event => ... /* 一些判断条件 */).or(event => ... /* 一些

你可以看到`{a1 a2 a3}`和`{a2 a3}`由于停止条件没有被输出。

{{< tabs "3b2dea6b-1615-47cb-bec5-2a281666dc4c" >}}
#### `where(condition)`

为当前模式定义一个条件。为了匹配这个模式，一个事件必须满足某些条件。 多个连续的 where() 语句取与组成判断条件。

{{< tabs "where" >}}
{{< tab "Java" >}}
<table class="table table-bordered">
<thead>
<tr>
<th class="text-left" style="width: 25%">模式操作</th>
<th class="text-center">描述</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>where(condition)</strong></td>
<td>
<p>为当前模式定义一个条件。为了匹配这个模式，一个事件必须满足某些条件。
多个连续的where()语句取与组成判断条件：</p>
```java
pattern.where(new IterativeCondition<Event>() {
@Override
Expand All @@ -411,233 +402,183 @@ pattern.where(new IterativeCondition<Event>() {
}
});
```
</td>
</tr>
<tr>
<td><strong>or(condition)</strong></td>
<td>
<p>增加一个新的判断，和当前的判断取或。一个事件只要满足至少一个判断条件就匹配到模式：</p>
{{< /tab >}}
{{< tab "Scala" >}}
```scala
pattern.where(event => ... /* 一些判断条件 */)
```
{{< /tab >}}
{{< /tabs >}}

#### `or(condition)`

增加一个新的判断，和当前的判断取或。一个事件只要满足至少一个判断条件就匹配到模式。

{{< tabs orcondition >}}
{{< tab "Java" >}}
```java
pattern.where(new IterativeCondition<Event>() {
@Override
public boolean filter(Event value, Context ctx) throws Exception {
return ... // 一些判断条件
return ...; // 一些判断条件
}
}).or(new IterativeCondition<Event>() {
@Override
public boolean filter(Event value, Context ctx) throws Exception {
return ... // 替代条件
return ...; // 替代条件
}
});
```
</td>
</tr>
<tr>
<td><strong>until(condition)</strong></td>
<td>
<p>为循环模式指定一个停止条件。意思是满足了给定的条件的事件出现后，就不会再有事件被接受进入模式了。</p>
<p>只适用于和<code>oneOrMore()</code>同时使用。</p>
<p><b>NOTE:</b> 在基于事件的条件中，它可用于清理对应模式的状态。</p>
{{< /tab >}}
{{< tab "Scala" >}}
```scala
pattern.where(event => ... /* 一些判断条件 */)
.or(event => ... /* 替代条件 */)
```
{{< /tab >}}
{{< /tabs >}}

#### `until(condition)`

为循环模式指定一个停止条件。意思是满足了给定的条件的事件出现后，就不会再有事件被接受进入模式了。
只适用于和oneOrMore()同时使用。
`NOTE:` 在基于事件的条件中，它可用于清理对应模式的状态。

{{< tabs untilcond >}}
{{< tab "Java" >}}
```java
pattern.oneOrMore().until(new IterativeCondition<Event>() {
@Override
public boolean filter(Event value, Context ctx) throws Exception {
return ... // 替代条件
return ...; // 替代条件
}
});
```
</td>
</tr>
<tr>
<td><strong>subtype(subClass)</strong></td>
<td>
<p>为当前模式定义一个子类型条件。一个事件只有是这个子类型的时候才能匹配到模式：</p>
{{< /tab >}}
{{< tab "Scala" >}}
```scala
pattern.oneOrMore().until(event => ... /* 一些判断条件 */)
```
{{< /tab >}}
{{< /tabs >}}

#### `subtype(subClass)`

为当前模式定义一个子类型条件。一个事件只有是这个子类型的时候才能匹配到模式。

{{< tabs subtype >}}
{{< tab "Java" >}}
```java
pattern.subtype(SubEvent.class);
```
</td>
</tr>
<tr>
<td><strong>oneOrMore()</strong></td>
<td>
<p>指定模式期望匹配到的事件至少出现一次。.</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
<p><b>NOTE:</b> 推荐使用<code>until()</code>或者<code>within()</code>来清理状态。</p>
{{< /tab >}}
{{< tab "Scala" >}}
```scala
pattern.subtype(classOf[SubEvent])
```
{{< /tab >}}
{{< /tabs >}}

#### `oneOrMore()`

指定模式期望匹配到的事件至少出现一次。
默认（在子事件间）使用松散的内部连续性。 关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。
推荐使用 until()或者 within()来清理状态。

{{< tabs oneormoe >}}
{{< tab "Java" >}}
```java
pattern.oneOrMore();
```
</td>
</tr>
<tr>
<td><strong>timesOrMore(#times)</strong></td>
<td>
<p>指定模式期望匹配到的事件至少出现<strong>#times</strong>次。.</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
{{< /tab >}}
{{< tab "Scala" >}}
```scala
pattern.oneOrMore()
```
{{< /tab >}}
{{< /tabs >}}

#### `timesOrMore(#times)`

指定模式期望匹配到的事件至少出现 #times 次。
默认（在子事件间）使用松散的内部连续性。 关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。

{{< tabs timesormore >}}
{{< tab "Java" >}}
```java
pattern.timesOrMore(2);
```
</td>
</tr>
<tr>
<td><strong>times(#ofTimes)</strong></td>
<td>
<p>指定模式期望匹配到的事件正好出现的次数。</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
{{< /tab >}}
{{< /tabs >}}

#### `times(#ofTimes)`

指定模式期望匹配到的事件正好出现的次数。
默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。

{{< tabs times >}}
{{< tab "Java" >}}
```java
pattern.times(2);
```
</td>
</tr>
<tr>
<td><strong>times(#fromTimes, #toTimes)</strong></td>
<td>
<p>指定模式期望匹配到的事件出现次数在<strong>#fromTimes</strong>和<strong>#toTimes</strong>之间。</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
{{< /tab >}}
{{< tab "Scala" >}}
```scala
pattern.times(2)
```
{{< /tab >}}
{{< /tabs >}}

#### `times(#fromTimes, #toTimes)`

指定模式期望匹配到的事件出现次数在#fromTimes和#toTimes之间。
默认（在子事件间）使用松散的内部连续性。 关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。

{{< tabs timesrange >}}
{{< tab "Java" >}}
```java
pattern.times(2, 4);
```
</td>
</tr>
<tr>
<td><strong>optional()</strong></td>
<td>
<p>指定这个模式是可选的，也就是说，它可能根本不出现。这对所有之前提到的量词都适用。</p>
{{< /tab >}}
{{< tab "Scala" >}}
```java
pattern.oneOrMore().optional();
pattern.times(2, 4)
```
</td>
</tr>
<tr>
<td><strong>greedy()</strong></td>
<td>
<p>指定这个模式是贪心的，也就是说，它会重复尽可能多的次数。这只对量词适用，现在还不支持模式组。</p>
{{< /tab >}}
{{< /tabs >}}

#### `optional()`

指定这个模式是可选的，也就是说，它可能根本不出现。这对所有之前提到的量词都适用。

{{< tabs optional >}}
{{< tab "Java" >}}
```java
pattern.oneOrMore().greedy();
pattern.oneOrMore().optional();
```
</td>
</tr>
</tbody>
</table>
{{< /tab >}}
{{< tab "Scala" >}}
<table class="table table-bordered">
<thead>
<tr>
<th class="text-left" style="width: 25%">模式操作</th>
<th class="text-center">描述</th>
</tr>
</thead>
<tbody>

<tr>
<td><strong>where(condition)</strong></td>
<td>
<p>为当前模式定义一个条件。为了匹配这个模式，一个事件必须满足某些条件。
多个连续的where()语句取与组成判断条件：</p>
```scala
pattern.where(event => ... /* 一些判断条件 */)
```
</td>
</tr>
<tr>
<td><strong>or(condition)</strong></td>
<td>
<p>增加一个新的判断，和当前的判断取或。一个事件只要满足至少一个判断条件就匹配到模式：</p>
```scala
pattern.where(event => ... /* 一些判断条件 */)
.or(event => ... /* 替代条件 */)
```
</td>
</tr>
<tr>
<td><strong>until(condition)</strong></td>
<td>
<p>为循环模式指定一个停止条件。意思是满足了给定的条件的事件出现后，就不会再有事件被接受进入模式了。</p>
<p>只适用于和<code>oneOrMore()</code>同时使用。</p>
<p><b>提示：</b> 在基于事件的条件中，它可用于清理对应模式的状态。</p>
```scala
pattern.oneOrMore().until(event => ... /* 替代条件 */)
```
</td>
</tr>
<tr>
<td><strong>subtype(subClass)</strong></td>
<td>
<p>为当前模式定义一个子类型条件。一个事件只有是这个子类型的时候才能匹配到模式：</p>
```scala
pattern.subtype(classOf[SubEvent])
```
</td>
</tr>
<tr>
<td><strong>oneOrMore()</strong></td>
<td>
<p>指定模式期望匹配到的事件至少出现一次。.</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
<p><b>提示：</b> 推荐使用<code>until()</code>或者<code>within()</code>来清理状态。</p>
```scala
pattern.oneOrMore()
```
</td>
</tr>
<tr>
<td><strong>timesOrMore(#times)</strong></td>
<td>
<p>指定模式期望匹配到的事件至少出现<strong>#times</strong>次。.</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
```scala
pattern.timesOrMore(2)
```
</td>
</tr>
<tr>
<td><strong>times(#ofTimes)</strong></td>
<td>
<p>指定模式期望匹配到的事件正好出现的次数。</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
```scala
pattern.times(2)
```
</td>
</tr>
<tr>
<td><strong>times(#fromTimes, #toTimes)</strong></td>
<td>
<p>指定模式期望匹配到的事件出现次数在<strong>#fromTimes</strong>和<strong>#toTimes</strong>之间。</p>
<p>默认（在子事件间）使用松散的内部连续性。
关于内部连续性的更多信息可以参考<a href="#consecutive_java">连续性</a>。</p>
```scala
pattern.times(2, 4)
```
</td>
</tr>
<tr>
<td><strong>optional()</strong></td>
<td>
<p>指定这个模式是可选的，也就是说，它可能根本不出现。这对所有之前提到的量词都适用。</p>
```scala
```java
pattern.oneOrMore().optional()
```
</td>
</tr>
<tr>
<td><strong>greedy()</strong></td>
<td>
<p>指定这个模式是贪心的，也就是说，它会重复尽可能多的次数。这只对量词适用，现在还不支持模式组。</p>
```scala
{{< /tab >}}
{{< /tabs >}}

#### `greedy()`

指定这个模式是贪心的，也就是说，它会重复尽可能多的次数。这只对量词适用，现在还不支持模式组。

{{< tabs greedy >}}
{{< tab "Java" >}}
```java
pattern.oneOrMore().greedy();
```
{{< /tab >}}
{{< tab "Scala" >}}
```java
pattern.oneOrMore().greedy()
```
</td>
</tr>
</tbody>
</table>
{{< /tab >}}
{{< /tabs >}}

Expand Down

0 comments on commit b51084d

Please sign in to comment.