@@ -187,114 +187,6 @@ pattern
187187
188188** 停止条件:** 如果使用循环模式(` oneOrMore() ` 和` oneOrMore().optional() ` ),你可以指定一个停止条件,例如,接受事件的值大于5直到值的和小于50。
189189
190- 为了更好的理解它,看下面的例子。给定
191- 192- - 模式如` "(a+ until b)" ` (一个或者更多的` "a" ` 直到` "b" ` )
193- - 到来的事件序列` "a1" "c" "a2" "b" "a3" `
194- - 输出结果会是: ` {a1 a2} {a1} {a2} {a3} ` .
195- 196- 你可以看到` {a1 a2 a3} ` 和` {a2 a3} ` 由于停止条件没有被输出。
197- 198- #### ` where(condition) `
199- 200- 为当前模式定义一个条件。为了匹配这个模式,一个事件必须满足某些条件。 多个连续的 where() 语句取与组成判断条件。
201- 202- ``` java
203- pattern. where(new IterativeCondition<Event > () {
204- @Override
205- public boolean filter (Event value , Context ctx ) throws Exception {
206- return ... // 一些判断条件
207- }
208- });
209- ```
210- 211- #### ` or(condition) `
212- 213- 增加一个新的判断,和当前的判断取或。一个事件只要满足至少一个判断条件就匹配到模式。
214- 215- ``` java
216- pattern. where(new IterativeCondition<Event > () {
217- @Override
218- public boolean filter (Event value , Context ctx ) throws Exception {
219- return ... ; // 一些判断条件
220- }
221- }). or(new IterativeCondition<Event > () {
222- @Override
223- public boolean filter (Event value , Context ctx ) throws Exception {
224- return ... ; // 替代条件
225- }
226- });
227- ```
228- 229- #### ` until(condition) `
230- 231- 为循环模式指定一个停止条件。意思是满足了给定的条件的事件出现后,就不会再有事件被接受进入模式了。 只适用于和oneOrMore()同时使用。 ` NOTE: ` 在基于事件的条件中,它可用于清理对应模式的状态。
232- 233- ``` java
234- pattern. oneOrMore(). until(new IterativeCondition<Event > () {
235- @Override
236- public boolean filter (Event value , Context ctx ) throws Exception {
237- return ... ; // 替代条件
238- }
239- });
240- ```
241- 242- #### ` subtype(subClass) `
243- 244- 为当前模式定义一个子类型条件。一个事件只有是这个子类型的时候才能匹配到模式。
245- 246- ``` java
247- pattern. subtype(SubEvent . class);
248- ```
249- 250- #### ` oneOrMore() `
251- 252- 指定模式期望匹配到的事件至少出现一次。 默认(在子事件间)使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。 推荐使用 until()或者 within()来清理状态。
253- 254- ``` java
255- pattern. oneOrMore();
256- ```
257- 258- #### ` timesOrMore(#times) `
259- 260- 指定模式期望匹配到的事件至少出现 #times 次。 默认(在子事件间)使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。
261- 262- ``` java
263- pattern. timesOrMore(2 );
264- ```
265- 266- #### ` times(#ofTimes) `
267- 268- 指定模式期望匹配到的事件正好出现的次数。 默认(在子事件间)使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。
269- 270- ``` java
271- pattern. times(2 );
272- ```
273- 274- #### ` times(#fromTimes, #toTimes) `
275- 276- 指定模式期望匹配到的事件出现次数在#fromTimes和#toTimes之间。 默认(在子事件间)使用松散的内部连续性。 关于内部连续性的更多信息可以参考连续性。
277- 278- ``` java
279- pattern. times(2 , 4 );
280- ```
281- 282- #### ` optional() `
283- 284- 指定这个模式是可选的,也就是说,它可能根本不出现。这对所有之前提到的量词都适用。
285- 286- ``` java
287- pattern. oneOrMore(). optional();
288- ```
289- 290- #### ` greedy() `
291- 292- 指定这个模式是贪心的,也就是说,它会重复尽可能多的次数。这只对量词适用,现在还不支持模式组。
293- 294- ``` java
295- pattern. oneOrMore(). greedy();
296- ```
297- 298190### 2.2 组合模式
299191
300192即模式序列,由一个初始模式作为开头:
@@ -387,125 +279,6 @@ Pattern.<Event>begin("start")
387279 .where(SimpleCondition . of(value - > value. getName(). equals(" b"
388280```
389281
390- 391- 392- 输入:C D A1 A2 A3 D A4 B,会产生下面的输出:
393- 394- 395- 396- 397- 398- 如果施加严格连续性: {C A1 B},{C A1 A2 B},{C A1 A2 A3 B}
399- 400- 不施加严格连续性: {C A1 B},{C A1 A2 B},{C A1 A2 A3 B},{C A1 A2 A3 A4 B}
401- 402- 例如,一个如下的模式:
403- 404- 405- 406- ``` java
407- Pattern . < Event > begin(" start"
408- .where(SimpleCondition . of(value - > value. getName(). equals(" c"
409- .followedBy(" middle"
410- .where(SimpleCondition . of(value - > value. getName(). equals(" a"
411- .oneOrMore()
412- .allowCombinations()
413- .followedBy(" end1"
414- .where(SimpleCondition . of(value - > value. getName(). equals(" b"
415- ```
416- 417- 418- 419- 输入:C D A1 A2 A3 D A4 B,会产生如下的输出:
420- 421- 422- 423- 424- 425- 如果使用不确定松散连续: {C A1 B},{C A1 A2 B},{C A1 A3 B},{C A1 A4 B},{C A1 A2 A3 B},{C A1 A2 A4 B},{C A1 A3 A4 B},{C A1 A2 A3 A4 B}
426- 427- 如果不使用:{C A1 B},{C A1 A2 B},{C A1 A2 A3 B},{C A1 A2 A3 A4 B}
428- 429- 430- 431- 432- 433- | 模式操作 | 描述 |
434- | ----------------- | ------------------------------------------------------------ |
435- | ** consecutive()** | 与` oneOrMore() ` 和` times() ` 一起使用, 在匹配的事件之间施加严格的连续性, 也就是说,任何不匹配的事件都会终止匹配(和` next() ` 一样)。如果不使用它,那么就是松散连续(和` followedBy() ` 一样)。 |
436- 437- 438- 439- 440- 441- 例如,一个如下的模式:
442- 443- 444- 445- ``` scala
446- Pattern .begin(" start" " c"
447- .followedBy(" middle" " a"
448- .oneOrMore().consecutive()
449- .followedBy(" end1" " b"
450- ```
451- 452- 453- 454- 输入:C D A1 A2 A3 D A4 B,会产生下面的输出:
455- 456- 457- 458- 459- 460- 如果施加严格连续性: {C A1 B},{C A1 A2 B},{C A1 A2 A3 B}
461- 462- 不施加严格连续性: {C A1 B},{C A1 A2 B},{C A1 A2 A3 B},{C A1 A2 A3 A4 B}
463- 464- 465- 466- ``` plain
467- </td>
468- </tr>
469- <tr>
470- <td><strong>allowCombinations()</strong><a name="allow_comb_java"></a></td>
471- <td>
472- <p>与<code>oneOrMore()</code>和<code>times()</code>一起使用,
473- 在匹配的事件中间施加不确定松散连续性(和<code>followedByAny()</code>一样)。</p>
474- <p>如果不使用,就是松散连续(和<code>followedBy()</code>一样)。</p>
475- ```
476- 477- 478- 479- 例如,一个如下的模式:
480- 481- 482- 483- ``` scala
484- Pattern .begin(" start" " c"
485- .followedBy(" middle" " a"
486- .oneOrMore().allowCombinations()
487- .followedBy(" end1" " b"
488- ```
489- 490- 491- 492- 输入:C D A1 A2 A3 D A4 B,会产生如下的输出:
493- 494- 495- 496- 497- 498- 如果使用不确定松散连续: {C A1 B},{C A1 A2 B},{C A1 A3 B},{C A1 A4 B},{C A1 A2 A3 B},{C A1 A2 A4 B},{C A1 A3 A4 B},{C A1 A2 A3 A4 B}
499- 500- 如果不使用:{C A1 B},{C A1 A2 B},{C A1 A2 A3 B},{C A1 A2 A3 A4 B}
501- 502- 503- 504- ``` plain
505- </td>
506- </tr>
507- ```
508- 509282### 2.3 模式组
510283
511284将一个模式序列作为条件嵌入在个体模式里。
0 commit comments