Matcher

abstract def apply(input: IterateeHelpers.OpenTag): Result[A]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def %(attribute: String): Parser[String]

def %?(attribute: String): Parser[Option[String]]

def &[B, AB](that: Matcher[B])(implicit rc: ContextCombiner[A, B, AB]): Matcher[AB]

def /[B, AB](that: Matcher[B])(implicit rc: ContextCombiner[A, B, AB]): ListMatcher[AB]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def andExtractName[AB](implicit rc: ContextCombiner[A, String, AB]): Matcher[AB]

Creates a tag matcher that will additionally return the name of the matched tag.

def as[Out](implicit innerParser: ParserBase[A, Out]): Parser[Out]

final def asInstanceOf[T0]: T0

def asList[Out](implicit innerParser: ParserBase[A, Out]): Parser[List[Out]]

def asOptional[Out](implicit innerParser: ParserBase[A, Out]): Parser[Option[Out]]

def attr(attribute: String): Parser[String]

def attrOpt(attribute: String): Parser[Option[String]]

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractName: Matcher[String]

Creates a tag matcher that, as long as this matcher gets a successful match, will throw out the successful result and replace it with the name of the element being matched.

def finalize(): Unit

def foreach[Out](thunk: (Out) ⇒ Unit)(implicit innerParser: ParserBase[A, Out]): Parser[Unit]

def foreachResult[Out](thunk: (Result[Out]) ⇒ Unit)(implicit innerParser: ParserBase[A, Out]): Parser[Unit]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def mapContext[In2](f: (A) ⇒ In2): Splitter[In2]

def matchContext(context: List[IterateeHelpers.OpenTag]): Result[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def text: Transformer[String]

def textConcat: Parser[String]

def textList: Parser[List[String]]

def textOption: Parser[Option[String]]

def through[Out](innerParser: ParserBase[A, Out]): Transformer[Out]

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def |[A1 >: A](that: Matcher[A1]): Matcher[A1]