Pattern

Instance Constructors

new Pattern(jPattern: pattern.Pattern[T, F])

jPattern
Underlying Java API Pattern

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def allowCombinations(): Pattern[T, F]

Applicable only to Quantifier.looping() and Quantifier.times() patterns, this option allows more flexibility to the matching events.
Applicable only to Quantifier.looping() and Quantifier.times() patterns, this option allows more flexibility to the matching events.
If
```
allowCombinations()
```
is not applied for a pattern
```
A.oneOrMore().followedBy(B)
```
and a sequence of events
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A.oneOrMore().followedBy(B) }}}
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
allowCombinations() }}} pattern
```
A.oneOrMore().followedBy(B)
```
and a sequence of events
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A.oneOrMore().followedBy(B) }}}
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. If this method is applied, we will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 A2 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
A1 B }}} will have
```
A1 B
```
,
```
A2 B
```
and
```
A1 A2 B
```
.
A1 A2 B }}}
A2 B }}}
A1 B }}}
returns
The same pattern with the updated quantifier.

Exceptions thrown
MalformedPatternException if the quantifier is not applicable to this pattern.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def consecutive(): Pattern[T, F]

Works in conjunction with Pattern#oneOrMore() or Pattern#times(int).
Works in conjunction with Pattern#oneOrMore() or Pattern#times(int). Specifies that any not matching element breaks the loop.
E.g. a pattern like:
```
Pattern.begin("start").where(_.getName().equals("c"))
       .followedBy("middle").where(_.getName().equals("a")).oneOrMore().consecutive()
       .followedBy("end1").where(_.getName().equals("b"));
```
For a sequence: C D A1 A2 A3 D A4 B
will generate matches: {C A1 B}, {C A1 A2 B}, {C A1 A2 A3 B}
By default a relaxed continuity is applied.
returns
pattern with continuity changed to strict
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def followedBy(pattern: Pattern[T, F]): GroupPattern[T, F]

Appends a new group pattern to the existing one.
Appends a new group pattern to the existing one. The new pattern enforces non-strict temporal contiguity. This means that a matching event of this pattern and the preceding matching event might be interleaved with other events which are ignored.
pattern
the pattern to append
returns
A new pattern which is appended to this one
def followedBy(name: String): Pattern[T, T]

Appends a new pattern to the existing one.
Appends a new pattern to the existing one. The new pattern enforces non-strict temporal contiguity. This means that a matching event of this pattern and the preceding matching event might be interleaved with other events which are ignored.
name
Name of the new pattern
returns
A new pattern which is appended to this one
def followedByAny(pattern: Pattern[T, F]): GroupPattern[T, F]

Appends a new group pattern to the existing one.
Appends a new group pattern to the existing one. The new pattern enforces non-strict temporal contiguity. This means that a matching event of this pattern and the preceding matching event might be interleaved with other events which are ignored.
pattern
the pattern to append
returns
A new pattern which is appended to this one
def followedByAny(name: String): Pattern[T, T]

Appends a new pattern to the existing one.
Appends a new pattern to the existing one. The new pattern enforces non-strict temporal contiguity. This means that a matching event of this pattern and the preceding matching event might be interleaved with other events which are ignored.
name
Name of the new pattern
returns
A new pattern which is appended to this one
def getAfterMatchSkipStrategy: AfterMatchSkipStrategy

Get after match skip strategy.
Get after match skip strategy.
returns
current after match skip strategy
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getCondition: Option[IterativeCondition[F]]
def getName: String

returns
Name of the pattern operator
def getPrevious: Option[Pattern[T, _ <: T]]

returns
The previous pattern
def getQuantifier: Quantifier

returns
currently applied quantifier to this pattern
def getUntilCondition: Option[IterativeCondition[F]]
def getWindowTime: Option[Time]

returns
Window length in which the pattern match has to occur
def greedy: Pattern[T, F]

Specifies that this pattern is greedy.
Specifies that this pattern is greedy. This means as many events as possible will be matched to this pattern.
returns
The same pattern with { @link Quantifier#greedy} set to true.

Exceptions thrown
MalformedPatternException if the quantifier is not applicable to this pattern.
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def next(pattern: Pattern[T, F]): GroupPattern[T, F]

Appends a new group pattern to the existing one.
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.
pattern
the pattern to append
returns
A new pattern which is appended to this one
def next(name: String): Pattern[T, T]

Appends a new pattern to the existing one.
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.
name
Name of the new pattern
returns
A new pattern which is appended to this one
def notFollowedBy(name: String): Pattern[T, T]

Appends a new pattern to the existing one.
Appends a new pattern to the existing one. The new pattern enforces that there is no event matching this pattern between the preceding pattern and succeeding this one.
NOTE: There has to be other pattern after this one.
name
Name of the new pattern
returns
A new pattern which is appended to this one
def notNext(name: String): Pattern[T, T]

Appends a new pattern to the existing one.
Appends a new pattern to the existing one. The new pattern enforces that there is no event matching this pattern right after the preceding matched event.
name
Name of the new pattern
returns
A new pattern which is appended to this one
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def oneOrMore: Pattern[T, F]

Specifies that this pattern can occur
Specifies that this pattern can occur
```
one or more
```
times. This means at least one and at most infinite number of events can be matched to this pattern.
If this quantifier is enabled for a pattern
```
A.oneOrMore().followedBy(B)
```
and a sequence of events
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
A.oneOrMore().followedBy(B) }}}
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
one or more }}} This means at least one and at most infinite number of events can be matched to this pattern.
If this quantifier is enabled for a pattern
```
A.oneOrMore().followedBy(B)
```
and a sequence of events
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
A.oneOrMore().followedBy(B) }}}
```
A1 A2 B
```
appears, this will generate patterns:
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
A1 A2 B }}}
```
A1 B
```
and
```
A1 A2 B
```
. See also
```
allowCombinations()
```
.
allowCombinations() }}}
A1 A2 B }}}
A1 B }}}
returns
The same pattern with a Quantifier.looping() quantifier applied.

Exceptions thrown
MalformedPatternException if the quantifier is not applicable to this pattern.
def optional: Pattern[T, F]

Specifies that this pattern is optional for a final match of the pattern sequence to happen.
Specifies that this pattern is optional for a final match of the pattern sequence to happen.
returns
The same pattern as optional.

Exceptions thrown
MalformedPatternException if the quantifier is not applicable to this pattern.
def or(condition: (F, Context[F]) ⇒ Boolean): Pattern[T, F]

Adds a condition that has to be satisfied by an event in order to be considered a match.
Adds a condition that has to be satisfied by an event in order to be considered a match. If another condition has already been set, the new one is going to be combined with the previous with a logical
```
OR
```
. In other case, this is going to be the only condition.
OR }}} condition.
condition
The
```
OR
```
returns
The pattern with the new condition is set.
def or(condition: (F) ⇒ Boolean): Pattern[T, F]

Adds a condition that has to be satisfied by an event in order to be considered a match.
Adds a condition that has to be satisfied by an event in order to be considered a match. If another condition has already been set, the new one is going to be combined with the previous with a logical
```
OR
```
. In other case, this is going to be the only condition.
OR }}} condition.
condition
The
```
OR
```
returns
The pattern with the new condition is set.
def or(condition: IterativeCondition[F]): Pattern[T, F]

Adds a condition that has to be satisfied by an event in order to be considered a match.
Adds a condition that has to be satisfied by an event in order to be considered a match. If another condition has already been set, the new one is going to be combined with the previous with a logical
```
OR
```
. In other case, this is going to be the only condition.
OR }}} condition.
condition
The condition as an IterativeCondition.
returns
The pattern with the new condition is set.
def subtype[S <: F](clazz: Class[S]): Pattern[T, S]

Applies a subtype constraint on the current pattern.
Applies a subtype constraint on the current pattern. This means that an event has to be of the given subtype in order to be matched.
S
Type of the subtype
clazz
Class of the subtype
returns
The same pattern with the new subtype constraint
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def times(from: Int, to: Int): Pattern[T, F]

Specifies that the pattern can occur between from and to times.
Specifies that the pattern can occur between from and to times.
from
number of times matching event must appear at least
to
number of times matching event must appear at most
returns
The same pattern with the number of times range applied

Exceptions thrown
MalformedPatternException if the quantifier is not applicable to this pattern.
def times(times: Int): Pattern[T, F]

Specifies exact number of times that this pattern should be matched.
Specifies exact number of times that this pattern should be matched.
times
number of times matching event must appear
returns
The same pattern with number of times applied

Exceptions thrown
MalformedPatternException if the quantifier is not applicable to this pattern.
def timesOrMore(times: Int): Pattern[T, F]

Specifies that this pattern can occur the specified times at least.
Specifies that this pattern can occur the specified times at least. This means at least the specified times and at most infinite number of events can be matched to this pattern.
returns
The same pattern with a { @link Quantifier#looping(ConsumingStrategy)} quantifier applied.

Exceptions thrown
MalformedPatternException if the quantifier is not applicable to this pattern.
def toString(): String

Definition Classes
AnyRef → Any
def until(untilCondition: (F) ⇒ Boolean): Pattern[T, F]

Applies a stop condition for a looping state.
Applies a stop condition for a looping state. It allows cleaning the underlying state.
untilCondition
a condition an event has to satisfy to stop collecting events into looping state
returns
The same pattern with applied untilCondition
def until(untilCondition: (F, Context[F]) ⇒ Boolean): Pattern[T, F]

Applies a stop condition for a looping state.
Applies a stop condition for a looping state. It allows cleaning the underlying state.
untilCondition
a condition an event has to satisfy to stop collecting events into looping state
returns
The same pattern with applied untilCondition
def until(untilCondition: IterativeCondition[F]): Pattern[T, F]

Applies a stop condition for a looping state.
Applies a stop condition for a looping state. It allows cleaning the underlying state.
untilCondition
a condition an event has to satisfy to stop collecting events into looping state
returns
The same pattern with applied untilCondition
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def where(condition: (F) ⇒ Boolean): Pattern[T, F]

Adds a condition that has to be satisfied by an event in order to be considered a match.
Adds a condition that has to be satisfied by an event in order to be considered a match. If another condition has already been set, the new one is going to be combined with the previous with a logical
```
AND
```
. In other case, this is going to be the only condition.
AND }}} condition.
condition
The condition to be set.
returns
The pattern with the new condition is set.
def where(condition: (F, Context[F]) ⇒ Boolean): Pattern[T, F]

Adds a condition that has to be satisfied by an event in order to be considered a match.
Adds a condition that has to be satisfied by an event in order to be considered a match. If another condition has already been set, the new one is going to be combined with the previous with a logical
```
AND
```
. In other case, this is going to be the only condition.
AND }}} condition.
condition
The condition to be set.
returns
The pattern with the new condition is set.
def where(condition: IterativeCondition[F]): Pattern[T, F]

Adds a condition that has to be satisfied by an event in order to be considered a match.
Adds a condition that has to be satisfied by an event in order to be considered a match. If another condition has already been set, the new one is going to be combined with the previous with a logical
```
AND
```
. In other case, this is going to be the only condition.
AND }}} condition.
condition
The condition as an IterativeCondition.
returns
The pattern with the new condition is set.
def within(windowTime: Time): Pattern[T, F]

Defines the maximum time interval in which a matching pattern has to be completed in order to be considered valid.
Defines the maximum time interval in which a matching pattern has to be completed in order to be considered valid. This interval corresponds to the maximum time gap between first and the last event.
windowTime
Time of the matching window
returns
The same pattern operator with the new window length

Related Docs: object Pattern | package pattern

class Pattern[T, F <: T] extends AnyRef

Instance Constructors

new Pattern(jPattern: pattern.Pattern[T, F])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def allowCombinations(): Pattern[T, F]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def consecutive(): Pattern[T, F]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def followedBy(pattern: Pattern[T, F]): GroupPattern[T, F]

def followedBy(name: String): Pattern[T, T]

def followedByAny(pattern: Pattern[T, F]): GroupPattern[T, F]

def followedByAny(name: String): Pattern[T, T]

def getAfterMatchSkipStrategy: AfterMatchSkipStrategy

final def getClass(): Class[_]

def getCondition: Option[IterativeCondition[F]]

def getName: String

def getPrevious: Option[Pattern[T, _ <: T]]

def getQuantifier: Quantifier

def getUntilCondition: Option[IterativeCondition[F]]

def getWindowTime: Option[Time]

def greedy: Pattern[T, F]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def next(pattern: Pattern[T, F]): GroupPattern[T, F]

def next(name: String): Pattern[T, T]

def notFollowedBy(name: String): Pattern[T, T]

def notNext(name: String): Pattern[T, T]

final def notify(): Unit

final def notifyAll(): Unit

def oneOrMore: Pattern[T, F]

def optional: Pattern[T, F]

def or(condition: (F, Context[F]) ⇒ Boolean): Pattern[T, F]

def or(condition: (F) ⇒ Boolean): Pattern[T, F]

def or(condition: IterativeCondition[F]): Pattern[T, F]

def subtype[S <: F](clazz: Class[S]): Pattern[T, S]

final def synchronized[T0](arg0: ⇒ T0): T0

def times(from: Int, to: Int): Pattern[T, F]

def times(times: Int): Pattern[T, F]

def timesOrMore(times: Int): Pattern[T, F]

def toString(): String

def until(untilCondition: (F) ⇒ Boolean): Pattern[T, F]

def until(untilCondition: (F, Context[F]) ⇒ Boolean): Pattern[T, F]

def until(untilCondition: IterativeCondition[F]): Pattern[T, F]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def where(condition: (F) ⇒ Boolean): Pattern[T, F]

def where(condition: (F, Context[F]) ⇒ Boolean): Pattern[T, F]

def where(condition: IterativeCondition[F]): Pattern[T, F]

def within(windowTime: Time): Pattern[T, F]

Inherited from AnyRef

Inherited from Any

Ungrouped