MarkupSpans

abstract def getSpanDirective(name: String): Option[directive.Directives.Spans.Directive]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object NoSuccess

def OnceParser[T](f: (Input) ⇒ ParseResult[T]): Parser[T] with OnceParser[T]

def Parser[T](f: (Input) ⇒ ParseResult[T]): Parser[T]

def accept[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def accept[ES](es: ES)(implicit arg0: (ES) ⇒ List[Elem]): Parser[List[Elem]]

implicit def accept(e: Elem): Parser[Elem]

def acceptIf(p: (Elem) ⇒ Boolean)(err: (Elem) ⇒ String): Parser[Elem]

def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U]

def acceptSeq[ES](es: ES)(implicit arg0: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

val any: TextParser

Consumes any kind of input, always succeeds.

def anyBut(chars: Char*): TextParser

Consumes any number of consecutive characters that are not one of the specified characters.

def anyIn(ranges: Traversable[Char]*): TextParser

Consumes any number of consecutive characters that are in one of the specified character ranges.

def anyOf(chars: Char*): TextParser

Consumes any number of consecutive occurrences of the specified characters.

def anyUntil(until: ⇒ Parser[Any]): TextParser

Consumes any number of characters for which the specified parser fails on the corresponding offset.

def anyUntil(chars: Char*): TextParser

Consumes any number of consecutive characters that are not one of the specified characters.

def anyWhile(p: (Char) ⇒ Boolean): TextParser

Consumes any number of consecutive characters which satisfy the specified predicate.

def applyDirective[E <: Element](builder: BuilderContext[E])(parseResult: ParsedDirective, directives: (String) ⇒ Option[Directive], createContext: (PartMap, Option[DocumentCursor]) ⇒ DirectiveContext, createPlaceholder: ((DocumentCursor) ⇒ E) ⇒ E, createInvalidElement: (String) ⇒ E, directiveTypeDesc: String): E

final def asInstanceOf[T0]: T0

val atStart: Parser[Unit]

Succeeds at the start of the input.

def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

def chainl1[T](p: ⇒ Parser[T], q: ⇒ Parser[(T, T) ⇒ T]): Parser[T]

def chainr1[T, U](p: ⇒ Parser[T], q: ⇒ Parser[(T, U) ⇒ U], combine: (T, U) ⇒ U, first: U): Parser[U]

implicit def charToTraversable(char: Char): Traversable[Char]

Implicit conversion that allows to pass a single character to the range-based anyIn parser.

def clone(): AnyRef

def commit[T](p: ⇒ Parser[T]): Parser[T]

lazy val declaration: Parser[(String, List[Part])]

Parses a full directive declaration, containing all its attributes, but not the body elements.

def directiveParser(bodyContent: Parser[String], includeStartChar: Boolean): Parser[ParsedDirective]

Parses one directive instance containing its name declaration, all attributes and all body elements.

def elem(e: Elem): Parser[Elem]

def elem(kind: String, p: (Elem) ⇒ Boolean): Parser[Elem]

def eof: Parser[String]

Succeeds at the end of the input.

def eol: Parser[String]

Succeeds at the end of a line, including the end of the input.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def err(msg: String): Parser[Nothing]

lazy val escapedChar: Parser[String]

Parses a single escape character.

def escapedText(p: TextParser): Parser[String]

Adds support for escape sequences to the specified text parser.

def escapedUntil(char: Char*): Parser[String]

Parses a span of text until one of the specified characters is seen (unless it is escaped), while also processing escaped characters, but no other nested spans.

def failure(msg: String): Parser[Nothing]

def finalize(): Unit

final def getClass(): Class[_]

def guard[T](p: ⇒ Parser[T]): Parser[T]

def handleWhiteSpace(source: CharSequence, offset: Int): Int

def hashCode(): Int

def inline[Elem, To](text: ⇒ TextParser, nested: ⇒ Map[Char, Parser[Elem]], resultBuilder: ⇒ ResultBuilder[Elem, To]): Parser[To]

Generic base parser that parses inline elements based on the specified helper parsers.

final def isInstanceOf[T0]: Boolean

implicit def literal(s: String): Parser[String]

def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

def lookBehind[T](offset: Int, parser: ⇒ Parser[T]): Parser[T]

Applies the specified parser at the specified offset behind the current position.

def mkList[T]: (~[T, List[T]]) ⇒ List[T]

lazy val nameDecl: Parser[String]

Parses a name declaration that start with a letter and continues with letters, numbers or the symbols '-' or '_'.

final def ne(arg0: AnyRef): Boolean

val nestedBraces: Parser[Text]

def not[T](p: ⇒ Parser[T]): Parser[Unit]

final def notify(): Unit

final def notifyAll(): Unit

def opt[T](p: ⇒ Parser[T]): Parser[Option[T]]

def optimizedCharLookup(chars: Char*): (Char) ⇒ Boolean

Returns an optimized, Array-based lookup function for the specified characters.

def optimizedRangeLookup(ranges: Traversable[Char]*): (Char) ⇒ Boolean

Returns an optimized, Array-based lookup function for the specified ranges of characters.

def parse[T](p: Parser[T], in: Reader): ParseResult[T]

def parse[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parse[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

def parseAll[T](p: Parser[T], in: CharSequence): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader): ParseResult[T]

def parseAll[T](p: Parser[T], in: Reader[Char]): ParseResult[T]

def parseInline(source: String): List[Span]

Fully parses the input string and produces a list of spans, using the default span parsers returned by the spanParsers method.

def parseInline(source: String, spanParsers: Map[Char, Parser[Span]]): List[Span]

Fully parses the input string and produces a list of spans.

def parseMarkup[T](parser: Parser[T], reader: Reader[Char]): T

Fully parses the input from the specified reader and returns the result.

def parseMarkup[T](parser: Parser[T], source: String): T

Fully parses the specified input string and returns the result.

def phrase[T](p: Parser[T]): Parser[T]

def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

def prepareSpanParsers: Map[Char, Parser[Span]]

Extension hook for modifying the default span parser map.

val refName: Parser[String]

Parses a simple reference name that only allows alphanumerical characters and the punctuation characters -, _, ., :, +.

def reference[T](f: (String) ⇒ T): Parser[T]

Parses a reference enclosed between {{ and }}.

implicit def regex(r: Regex): Parser[String]

def rep[T](first: ⇒ Parser[T], next: (T) ⇒ Parser[T]): Parser[List[T]]

A parser generator for repetitions where all subsequent parsers after the first depend on the result of the previous.

def rep[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](first: ⇒ Parser[T], p0: ⇒ Parser[T]): Parser[List[T]]

def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

def rep1sep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def repMax[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Uses the parser for at most the specified number of repetitions, always succeeds.

def repMin[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

Uses the parser for at least the specified number of repetitions or otherwise fails.

def repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

def repsep[T](p: ⇒ Parser[T], q: ⇒ Parser[Any]): Parser[List[T]]

def skipWhitespace: Boolean

lazy val spanDirectiveParser: Parser[Span]

final lazy val spanParsers: Map[Char, Parser[Span]]

The mapping of markup start characters to their corresponding span parsers.

def spans(parser: ⇒ TextParser, spanParsers: ⇒ Map[Char, Parser[Span]]): Parser[List[Span]]

Parses a list of spans based on the specified helper parsers.

def success[T](v: T): Parser[T]

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

def text(parser: ⇒ TextParser, nested: ⇒ Map[Char, Parser[String]]): Parser[String]

Parses text based on the specified helper parsers.

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val whiteSpace: Regex

def withSource[T](p: Parser[T]): Parser[(T, String)]

Groups the result of the parser and the source string that it successfully parsed into a tupled result.

def ws: TextParser

Parses horizontal whitespace (space and tab).

lazy val wsOrNl: TextParser

Parses horizontal whitespace or newline characters.

def lastNoSuccess: NoSuccess

def lastNoSuccess_=(x: NoSuccess): Unit