Mapped

case class Mapped[Item, A, B](inner: SingleItemContextMatcher[Item, A], op: String)(f: A => Option[B]) extends SingleItemContextMatcher[Item, B]

Similar to ContextMatcher.Mapped, but specialized for SingleElementContextMatcher

trait Serializable
trait Product
trait Equals
trait ContextMatcher[Item, B]
class Object
trait Matchable
class Any

Value members

Concrete methods

def applyElem(elem: Item): Option[B]
override def filter(p: B => Boolean): SingleItemContextMatcher[Item, B]
override def flatMap[B2](g: B => Option[B2]): SingleItemContextMatcher[Item, B2]
override def map[B2](g: B => B2): SingleItemContextMatcher[Item, B2]
override def toString: String
Definition Classes
Any

Inherited methods

def &[A1 >: B, B, R](that: SingleItemContextMatcher[Item, B])(implicit reduce: Aux[A1, B, R]): SingleItemContextMatcher[Item, R]

Operator version of and

Operator version of and

Inherited from:
SingleItemContextMatcher
def \[A1 >: B, B, R](next: ContextMatcher[Item, B])(implicit reduce: Aux[A1, B, R]): ContextMatcher[Item, R]

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.

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.

Type parameters:
A1

To satisfy covariance on A

B

The next matcher's context type

R

The "reduced" content type, derived from the tuple type (A, B) based on the reduce rule.

Value parameters:
next

A matcher which will be used to match the "inner" context

reduce

The TypeReduce rule to help omit Unit from the resulting context type

Returns:

A matcher which delegates to this matcher first, then the next matcher for the remaining stack.

Inherited from:
ContextMatcher
def and[A1 >: B, B, R](that: SingleItemContextMatcher[Item, B])(implicit reduce: Aux[A1, B, R]): SingleItemContextMatcher[Item, R]

Creates a new single-element matcher which combines the results of both this matcher and that matcher. Both this and that will operate on the first element of the stack (as opposed to Chained matchers).

Creates a new single-element matcher which combines the results of both this matcher and that matcher. Both this and that will operate on the first element of the stack (as opposed to Chained matchers).

Type parameters:
A1

To satisfy covariance on A

B

The other matcher's result type

R

The combined result type

Value parameters:
reduce

The TypeReduce rule for combining the two match results

that

The matcher to combine

Returns:

A new matcher which combines the results of this and that

Inherited from:
SingleItemContextMatcher
def apply(stack: IndexedSeq[Item], offset: Int, avail: Int): Option[B]

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.

Value parameters:
avail

The number of elements available in the stack starting from the offset.

offset

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)

stack

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.

Returns:

An option containing the successfully-matched context, or None.

Inherited from:
ContextMatcher
def applyChained[B](stack: IndexedSeq[Item], offset: Int, avail: Int, next: ContextMatcher[Item, B]): Option[(B, B)]
def or[A2 >: B](that: SingleItemContextMatcher[Item, A2]): SingleItemContextMatcher[Item, A2]

Specialization of the default or method, specifically for SingleElementContextMatchers

Specialization of the default or method, specifically for SingleElementContextMatchers

Inherited from:
SingleItemContextMatcher
def or[A2 >: B](that: ContextMatcher[Item, A2]): ContextMatcher[Item, A2]

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.

Type parameters:
A2

The resulting context type (common supertype between this matcher and that)

Value parameters:
that

The matcher which will be used as the fallback

Returns:

A matcher that falls back to another matcher in case of failure

Inherited from:
ContextMatcher
def productElementNames: Iterator[String]
Inherited from:
Product
def productIterator: Iterator[Any]
Inherited from:
Product
def |[A2 >: B](that: SingleItemContextMatcher[Item, A2]): SingleItemContextMatcher[Item, A2]

Operator version of or, specialized for SingleElementContextMatchers

Operator version of or, specialized for SingleElementContextMatchers

Inherited from:
SingleItemContextMatcher
def |[A2 >: B](that: ContextMatcher[Item, A2]): ContextMatcher[Item, A2]

Operator version of or

Operator version of or

Inherited from:
ContextMatcher