DefaultRecursiveParsers

Abstract Value Members

abstract def blockList(p: ⇒ Parser[Block]): Parser[Seq[Block]]

Builds a parser for a list of blocks based on the parser for a single block.
Builds a parser for a list of blocks based on the parser for a single block.

Attributes
protected
abstract def fallbackBlock: Parser[Block]

Parses blocks, excluding blocks that allow nesting.
Parses blocks, excluding blocks that allow nesting. Only used in rare cases when the maximum nest level allowed had been reached

Attributes
protected
abstract def nestedBlock: Parser[Block]

Parses any kind of nested block supported by a concrete markup language.
Parses any kind of nested block supported by a concrete markup language.

Attributes
protected
abstract def rootBlock: Parser[Block]

Parses any kind of top-level block supported by a concrete markup language.
Parses any kind of top-level block supported by a concrete markup language.

Attributes
protected
abstract def spanParsers: Map[Char, Parser[Span]]

The mapping of markup start characters to their corresponding span parsers.
The mapping of markup start characters to their corresponding span parsers.
A parser mapped to a start character is not required to successfully parse the subsequent input. If it fails the character that triggered the parser invocation will be treated as normal text. The mapping is merely used as a performance optimization. The parser will be invoked with the input offset pointing to the character after the one specified as the key for the mapping.

Attributes
protected
Definition Classes
DefaultRecursiveSpanParsers

Concrete 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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def delimitedRecursiveSpans(textParser: DelimitedText[String]): Parser[List[Span]]

Lifts the specified text parser to parse the string result as a sequence of spans.
Lifts the specified text parser to parse the string result as a sequence of spans.
This type of span parser is usually used in inline parsers, that need to process inline markup for a span with a delimiter while supporting nested spans.

Definition Classes
DefaultRecursiveSpanParsers → RecursiveSpanParsers
def delimitedRecursiveSpans(textParser: DelimitedText[String], additionalSpanParsers: ⇒ Map[Char, Parser[Span]]): Parser[List[Span]]

Lifts the specified text parser to parse the string result as a sequence of spans.
Lifts the specified text parser to parse the string result as a sequence of spans. Adds the specified additional parsers to the span parsers of the host markup language.
This type of span parser is usually used in inline parsers, that need to process inline markup for a span with a delimiter while supporting nested spans.

Definition Classes
DefaultRecursiveSpanParsers → RecursiveSpanParsers
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
lazy val escapedChar: Parser[String]

Parses a single escape character.
Parses a single escape character. In the default implementation any character can be escaped. Sub-traits may override this parser to restrict the number of escapable characters.

Definition Classes
DefaultEscapedTextParsers → EscapedTextParsers
def escapedText(p: DelimitedText[String]): Parser[String]

Adds support for escape sequences to the specified text parser.
Adds support for escape sequences to the specified text parser.
p
the parser to add support for escape sequences to
returns
a parser for a text span that supports escape sequences

Definition Classes
DefaultEscapedTextParsers → EscapedTextParsers
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.
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. The final character is not included in the result.
char
the character(s) that signals the end of the text span
returns
a parser for a text span that supports escape sequences

Definition Classes
DefaultEscapedTextParsers → EscapedTextParsers
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

Definition Classes
Any
val maxNestLevel: Int

The maximum level of block nesting.
The maximum level of block nesting. Some block types like lists and blockquotes contain nested blocks. To protect against malicious input or accidentally broken markup, the level of nesting is restricted.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def recursiveBlocks(p: Parser[String]): Parser[Seq[Block]]

Lifts the specified text parser to parse the string result as a sequence of blocks.
Lifts the specified text parser to parse the string result as a sequence of blocks.
This type of span parser is usually used in block parsers, that support the nesting of other blocks.

Definition Classes
DefaultRecursiveParsers → RecursiveParsers
def recursiveSpans: Parser[List[Span]]

Parses the input into a sequence of spans based on the available span types of the host markup language.
Parses the input into a sequence of spans based on the available span types of the host markup language.
This parser always parses to the end of the input, therefore is usually applied to the string result of a previous parser invocation.

Definition Classes
DefaultRecursiveSpanParsers → RecursiveSpanParsers
def recursiveSpans(p: Parser[String], additionalParsers: ⇒ Map[Char, Parser[Span]] = Map.empty): Parser[List[Span]]

Lifts the specified text parser to parse the string result as a sequence of spans.
Lifts the specified text parser to parse the string result as a sequence of spans. Adds the specified additional parsers to the span parsers of the host markup language.
This type of span parser is usually used in block parsers, that need to process inline markup after the text for the block has been parsed from the input string.

Definition Classes
DefaultRecursiveSpanParsers → RecursiveSpanParsers
def recursiveSpans(p: Parser[String]): Parser[List[Span]]

Lifts the specified text parser to parse the string result as a sequence of spans.
Lifts the specified text parser to parse the string result as a sequence of spans.
This type of span parser is usually used in block parsers, that need to process inline markup after the text for the block has been parsed from the input string.

Definition Classes
DefaultRecursiveSpanParsers → RecursiveSpanParsers
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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 withRecursiveBlockParser[T](p: Parser[T]): Parser[((String) ⇒ Seq[Block], T)]

Adds a block parser function to the result of the specified parser.
Adds a block parser function to the result of the specified parser. The function can be used for any kind of custom block parsing of portions of the result produced by the base parser.
The parser function never fails, but instead inserts blocks of type InvalidBlock into the result in case of errors.

Definition Classes
DefaultRecursiveParsers → RecursiveParsers
def withRecursiveSpanParser[T](p: Parser[T]): Parser[((String) ⇒ List[Span], T)]

Adds a span parser function to the result of the specified parser.
Adds a span parser function to the result of the specified parser. The function can be used for any kind of custom span parsing of portions of the result produced by the base parser.
The parser function never fails, but instead inserts spans of type InvalidSpan into the result in case of errors.

Definition Classes
DefaultRecursiveSpanParsers → RecursiveSpanParsers

Related Doc: package markup

trait DefaultRecursiveParsers extends RecursiveParsers with DefaultRecursiveSpanParsers

Abstract Value Members

abstract def blockList(p: ⇒ Parser[Block]): Parser[Seq[Block]]

abstract def fallbackBlock: Parser[Block]

abstract def nestedBlock: Parser[Block]

abstract def rootBlock: Parser[Block]

abstract def spanParsers: Map[Char, Parser[Span]]

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def delimitedRecursiveSpans(textParser: DelimitedText[String]): Parser[List[Span]]

def delimitedRecursiveSpans(textParser: DelimitedText[String], additionalSpanParsers: ⇒ Map[Char, Parser[Span]]): Parser[List[Span]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

lazy val escapedChar: Parser[String]

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

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

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

val maxNestLevel: Int

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def recursiveBlocks(p: Parser[String]): Parser[Seq[Block]]

def recursiveSpans: Parser[List[Span]]

def recursiveSpans(p: Parser[String], additionalParsers: ⇒ Map[Char, Parser[Span]] = Map.empty): Parser[List[Span]]

def recursiveSpans(p: Parser[String]): Parser[List[Span]]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withRecursiveBlockParser[T](p: Parser[T]): Parser[((String) ⇒ Seq[Block], T)]

def withRecursiveSpanParser[T](p: Parser[T]): Parser[((String) ⇒ List[Span], T)]

Inherited from DefaultRecursiveSpanParsers

Inherited from DefaultEscapedTextParsers

Inherited from RecursiveParsers

Inherited from RecursiveSpanParsers

Inherited from EscapedTextParsers

Inherited from AnyRef

Inherited from Any

Ungrouped