The underlying context match method.
The underlying context match method.
Inspects the elements in the XML "tag stack", which is essentially a List[StartElement], but for
performance reasons is represented as an array with an "offset" index and a number of available
elements from that offset. If the elements correspond to a context value of A, the implementation
must then pass the remaining elements of the stack to the next matcher, i.e. by calling
next(stack, offset + numConsumed, avail - numConsumed).
The next matcher is necessary in order to support non-greedy matchers, e.g. ContextMatcher.variableLength,
a.k.a. **. Without a reference to the next matcher in the chain, matcher implementations would be
forced to pick a fixed number of elements for matching, never knowing that the overall match could have
succeeded if they had consumed some additional elements.
The next matcher's context type
A reference to the complete XML "tag stack". Note that the responsibility of this method
is limited to a *slice* of this value, as defined by offset and avail.
The index of the first element to be considered by the matching logic. From this method's
point of view, the "first" element in the stack is actually at stack(offset)
The number of elements available in the stack starting from the offset.
The next matcher in the chain.
If the match succeeded, and the next match succeded, an Option containing a tuple of both match results.
If the match failed, or if the next match failed, None.
Create a new matcher by forming a chain with this matcher at the front, and the next matcher at the back.
Create a new matcher by forming a chain with this matcher at the front, and the next matcher at the back.
In other words, a matcher for a context within another context.
To satisfy covariance on A
The next matcher's context type
The "reduced" content type, derived from the tuple type (A, B) based on the reduce rule.
A matcher which will be used to match the "inner" context
The TypeReduce rule to help omit Unit from the resulting context type
A matcher which delegates to this matcher first, then the next matcher for the remaining stack.
The main context match method.
The main context match method.
Inspects the elements in the XML "tag stack", which is essentially a List[StartElement], but for
performance reasons is represented as an array with an "offset" index and a number of available
elements from that offset. If the elements correspond to a context value of A, the implementation
must then pass the remaining elements of the stack to the next matcher, i.e. by calling
next(stack, offset + numConsumed, avail - numConsumed).
The difference between this method and applyChained is the lack of the next parameter; in this
method, the current matcher is assumed to be the end of the chain.
A reference to the complete XML "tag stack". Note that the responsibility of this method
is limited to a *slice* of this value, as defined by offset and avail.
The index of the first element to be considered by the matching logic. From this method's
point of view, the "first" element in the stack is actually at stack(offset)
The number of elements available in the stack starting from the offset.
An option containing the successfully-matched context, or None.
Create a new ContextMatcher which takes the match result of this matcher and passes it through the
validation function f.
Create a new ContextMatcher which takes the match result of this matcher and passes it through the
validation function f. If f returns false, the match is unsuccessful.
The filter predicate, i.e. the validation function
A new matcher with validated results
Create a new ContextMatcher which takes the match result of this matcher and passes it through the
combined transformation/validation function f.
Create a new ContextMatcher which takes the match result of this matcher and passes it through the
combined transformation/validation function f. If f returns None, the match is unsuccessful;
if f returns a Some, the value inside is the result of the match.
The transformed context type
The transformation/validation function
A new matcher with transformed and validated results
Create a new ContextMatcher which takes the match result of this matcher and passes it through the
transformation function f.
Create a new ContextMatcher which takes the match result of this matcher and passes it through the
transformation function f.
The transformed context type
The transformation function
A new matcher with transformed results
Create a new ContextMatcher which will fall back to a second matcher in the event that this matcher fails to match a context.
Create a new ContextMatcher which will fall back to a second matcher in the event that this matcher fails to match a context.
The resulting context type (common supertype between this matcher and that)
The matcher which will be used as the fallback
A matcher that falls back to another matcher in case of failure
Operator version of or
(contextMatcher: StringAdd).self
(contextMatcher: StringFormat).self
(contextMatcher: ArrowAssoc[ContextMatcher[A]]).x
(Since version 2.10.0) Use leftOfArrow instead
(contextMatcher: Ensuring[ContextMatcher[A]]).x
(Since version 2.10.0) Use resultOfEnsuring instead
An object responsible for inspecting a stack of
StartElementevents and determining if they correspond to some "context" value of typeA.ContextMatchers play a primary role in splitting an XML event stream into "substreams", i.e. each substream is defined as the series of consecutive events during which the XML tag stack matches a context.ContextMatchers are intended to be transformed and combined with each other in order to build up more complex matching functionality. See also:SingleElementContextMatcher, which contains additional combination methods and some specialized transformation methods.The type of the matched context.