SspParser 1.9.0 - org.fusesource.scalate.ssp.SspParser

Instance Constructors

new SspParser()

Type Members

type Elem = Char

Definition Classes
RegexParsers → Parsers
case class Error extends NoSuccess with Product with Serializable

Definition Classes
Parsers
case class Failure extends NoSuccess with Product with Serializable

Definition Classes
Parsers
type Input = Reader[Elem]

Definition Classes
Parsers
sealed abstract class NoSuccess extends ParseResult[Nothing]

Definition Classes
Parsers
trait OnceParser[+T] extends Parser[T]

Definition Classes
Parsers
sealed abstract class ParseResult[+T] extends AnyRef

Definition Classes
Parsers
abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

Definition Classes
Parsers
case class Success[+T] extends ParseResult[T] with Product with Serializable

Definition Classes
Parsers
case class ~[+a, +b] extends Product with Serializable

Definition Classes
Parsers

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def +(other: String): String

Implicit information
This member is added by an implicit conversion from SspParser to any2stringadd[SspParser] performed by method any2stringadd in scala.Predef.
Definition Classes
any2stringadd
def ->[B](y: B): (SspParser, B)

Implicit information
This member is added by an implicit conversion from SspParser to ArrowAssoc[SspParser] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc
Annotations
@inline()
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
val EofCh: Char

Definition Classes
ScalaParseSupport
object NoSuccess

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

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

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

Definition Classes
ScalaParseSupport → Parsers
def accept[ES](es: ES)(implicit f: (ES) ⇒ List[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
implicit def accept(e: Elem): Parser[Elem]

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

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

Definition Classes
Parsers
def acceptSeq[ES](es: ES)(implicit f: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

Definition Classes
Parsers
val altCommentFragment: Parser[CommentFragment]
lazy val anyChar: Parser[Char]

Definition Classes
ScalaParseSupport
val anySpace: Parser[Text]
final def asInstanceOf[T0]: T0

Definition Classes
Any
val attribute: Parser[AttributeFragment]
val attributeFragement: Parser[AttributeFragment]
def caseExpression: Parser[CaseFragment]
def chainl1[T, U](first: ⇒ Parser[T], p: ⇒ Parser[U], q: ⇒ Parser[(T, U) ⇒ T]): Parser[T]

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

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

Definition Classes
Parsers
lazy val charEscapeSeq: Parser[Char]

Definition Classes
ScalaParseSupport
lazy val characterLiteral: Parser[String]

Definition Classes
ScalaParseSupport
def chrExcept(cs: Char*): Parser[Char]

Definition Classes
ScalaParseSupport
def chrOf(cs: String): Parser[Char]

Definition Classes
ScalaParseSupport
def chrOf(cs: Char*): Parser[Char]

Definition Classes
ScalaParseSupport
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val commentFragment: Parser[CommentFragment]
def commit[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def directives: Parser[PageFragment]
def doExpression: Parser[DoFragment]
val dollarExpressionFragment: Parser[DollarExpressionFragment]
lazy val doubleQuotedChars: Parser[String]

Definition Classes
ScalaParseSupport
def dquoted[T](p: Parser[T]): Parser[T]

Definition Classes
ScalaParseSupport
def elem(e: Elem): Parser[Elem]

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

Definition Classes
Parsers
def elseExpression: Parser[ElseFragment]
def elseIfExpression: Parser[ElseIfFragment]
def emptyDirective(name: String): Parser[Text]
def endExpression: Parser[EndFragment]
def ensuring(cond: (SspParser) ⇒ Boolean, msg: ⇒ Any): SspParser

Implicit information
This member is added by an implicit conversion from SspParser to Ensuring[SspParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: (SspParser) ⇒ Boolean): SspParser

Implicit information
This member is added by an implicit conversion from SspParser to Ensuring[SspParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean, msg: ⇒ Any): SspParser

Implicit information
This member is added by an implicit conversion from SspParser to Ensuring[SspParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
def ensuring(cond: Boolean): SspParser

Implicit information
This member is added by an implicit conversion from SspParser to Ensuring[SspParser] performed by method Ensuring in scala.Predef.
Definition Classes
Ensuring
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def err(msg: String): Parser[Nothing]

Definition Classes
Parsers
def expressionDirective[T](p: Parser[T]): Parser[Text]
def expressionDirective(name: String): Parser[Text]
val expressionFragment: Parser[ExpressionFragment]
def failure(msg: String): Parser[Nothing]

Definition Classes
Parsers
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def forExpression: Parser[ForFragment]
def formatted(fmtstr: String): String

Implicit information
This member is added by an implicit conversion from SspParser to StringFormat[SspParser] performed by method StringFormat in scala.Predef.
Definition Classes
StringFormat
Annotations
@inline()
def getAttribute(in: String): AttributeFragment
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getPageFragments(in: String): List[PageFragment]
def guard[T](p: ⇒ Parser[T]): Parser[T]

Definition Classes
Parsers
def guarded[T, U](p1: Parser[T], p2: Parser[U]): Parser[U]

Once p1 is matched, disable backtracking.
Once p1 is matched, disable backtracking. Does not consume p1 and yields the result of p2

Definition Classes
ScalaParseSupport
def handleWhiteSpace(source: CharSequence, offset: Int): Int

Attributes
protected
Definition Classes
RegexParsers
def hashCode(): Int

Definition Classes
AnyRef → Any
lazy val hexDigit: Parser[Char]

Definition Classes
ScalaParseSupport
val identifier: Parser[Text]
def ifExpression: Parser[IfFragment]
def importExpression: Parser[ImportFragment]
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
implicit def literal(s: String): Parser[String]

Definition Classes
RegexParsers
val literalPart: Parser[Text]
def log[T](p: ⇒ Parser[T])(name: String): Parser[T]

Definition Classes
Parsers
def matchExpression: Parser[MatchFragment]
def mkList[T]: (~[T, List[T]]) ⇒ List[T]

Definition Classes
Parsers
lazy val multiLineChars: Parser[String]

Definition Classes
ScalaParseSupport
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val nonParenText: Parser[String]
def not[T](p: ⇒ Parser[T]): Parser[Unit]

Definition Classes
Parsers
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
lazy val octalDigit: Parser[Char]

Definition Classes
ScalaParseSupport
lazy val octalEscapeSeq: Parser[Char]

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

Definition Classes
Parsers
def otherwiseExpression: Parser[OtherwiseFragment]
val pageFragment: Parser[PageFragment]
val pageFragments: Parser[List[PageFragment]]
def parse[T](p: Parser[T], in: Reader): ParseResult[T]

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

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

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

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

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

Definition Classes
RegexParsers
def phrase[T](p: Parser[T]): Parser[T]

Definition Classes
RegexParsers → Parsers
def positioned[T <: Positional](p: ⇒ Parser[T]): Parser[T]

Definition Classes
RegexParsers → Parsers
def prefixed[T, U](p1: Parser[T], p2: Parser[U]): Parser[U]

Once p1 is matched, disable backtracking.
Once p1 is matched, disable backtracking. Consumes p1 and yields the result of p2

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

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

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

Definition Classes
Parsers
Annotations
@migration
Migration
(Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
def rep1[T](p: ⇒ Parser[T]): Parser[List[T]]

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

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

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

Definition Classes
Parsers
def scalaExpression: Parser[Text]
val scalaType: Regex

Definition Classes
ScalaParseSupport
val scalaTypeChar: String

Definition Classes
ScalaParseSupport
val scriptletFragment: Parser[ScriptletFragment]
def setExpression: Parser[SetFragment]
def skipWhitespace: Boolean

Definition Classes
SspParser → RegexParsers
var skipWhitespaceOn: Boolean
def skip_whitespace[T](p: ⇒ Parser[T]): Parser[T]
val someText: Parser[Text]
def someUpto[T](p: Parser[T]): Parser[Text]

Definition Classes
ScalaParseSupport
def squoted[T](p: Parser[T]): Parser[T]

Definition Classes
ScalaParseSupport
lazy val stringLiteral: Parser[String]

Definition Classes
ScalaParseSupport
def success[T](v: T): Parser[T]

Definition Classes
Parsers
def surround[T](delim: Parser[Any], p: Parser[T]): Parser[T]

Definition Classes
ScalaParseSupport
def surround[T](c: Char, p: Parser[T]): Parser[T]

Definition Classes
ScalaParseSupport
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
val tagEnding: Parser[String]
def takeUntil(cond: Parser[Any], p: Parser[Char]): Parser[String]

Definition Classes
ScalaParseSupport
def takeUntil(cond: Parser[Any]): Parser[String]

Definition Classes
ScalaParseSupport
def takeWhile(p: Parser[Char]): Parser[String]

Definition Classes
ScalaParseSupport
def text(p1: Parser[String]): Parser[Text]

Definition Classes
ScalaParseSupport
val textFragment: Parser[TextFragment]
def toString(): String

Definition Classes
AnyRef → Any
def tquoted[T](p: Parser[T]): Parser[T]

Definition Classes
ScalaParseSupport
lazy val tripleQuote: Parser[Unit]

Definition Classes
ScalaParseSupport
val typeName: Parser[Text]
lazy val uniEscapeSeq: Parser[Char]

Definition Classes
ScalaParseSupport
def upto[T](p: Parser[T]): Parser[Text]

Definition Classes
ScalaParseSupport
def velocityScriplet: Parser[ScriptletFragment]
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( ... )
val whiteSpace: Regex

Attributes
protected
Definition Classes
RegexParsers
def wrapped[T, U](prefix: Parser[T], postfix: Parser[U]): Parser[Text]

Definition Classes
ScalaParseSupport
def →[B](y: B): (SspParser, B)

Implicit information
This member is added by an implicit conversion from SspParser to ArrowAssoc[SspParser] performed by method ArrowAssoc in scala.Predef.
Definition Classes
ArrowAssoc

Inherited from ScalaParseSupport

Inherited from RegexParsers

Inherited from Parsers

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from SspParser to any2stringadd[SspParser]

Inherited by implicit conversion StringFormat from SspParser to StringFormat[SspParser]

Inherited by implicit conversion Ensuring from SspParser to Ensuring[SspParser]

Inherited by implicit conversion ArrowAssoc from SspParser to ArrowAssoc[SspParser]

Ungrouped

SspParser

Related Doc: package ssp

class SspParser extends ScalaParseSupport

Instance Constructors

new SspParser()

Type Members

type Elem = Char

case class Error extends NoSuccess with Product with Serializable

case class Failure extends NoSuccess with Product with Serializable

type Input = Reader[Elem]

sealed abstract class NoSuccess extends ParseResult[Nothing]

trait OnceParser[+T] extends Parser[T]

sealed abstract class ParseResult[+T] extends AnyRef

abstract class Parser[+T] extends (Input) ⇒ ParseResult[T]

case class Success[+T] extends ParseResult[T] with Product with Serializable

case class ~[+a, +b] extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (SspParser, B)

final def ==(arg0: Any): Boolean

val EofCh: Char

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 f: (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 f: (ES) ⇒ Iterable[Elem]): Parser[List[Elem]]

val altCommentFragment: Parser[CommentFragment]

lazy val anyChar: Parser[Char]

val anySpace: Parser[Text]

final def asInstanceOf[T0]: T0

val attribute: Parser[AttributeFragment]

val attributeFragement: Parser[AttributeFragment]

def caseExpression: Parser[CaseFragment]

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]

lazy val charEscapeSeq: Parser[Char]

lazy val characterLiteral: Parser[String]

def chrExcept(cs: Char*): Parser[Char]

def chrOf(cs: String): Parser[Char]

def chrOf(cs: Char*): Parser[Char]

def clone(): AnyRef

val commentFragment: Parser[CommentFragment]

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

def directives: Parser[PageFragment]

def doExpression: Parser[DoFragment]

val dollarExpressionFragment: Parser[DollarExpressionFragment]

lazy val doubleQuotedChars: Parser[String]

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

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

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

def elseExpression: Parser[ElseFragment]

def elseIfExpression: Parser[ElseIfFragment]

def emptyDirective(name: String): Parser[Text]

def endExpression: Parser[EndFragment]

def ensuring(cond: (SspParser) ⇒ Boolean, msg: ⇒ Any): SspParser

def ensuring(cond: (SspParser) ⇒ Boolean): SspParser

def ensuring(cond: Boolean, msg: ⇒ Any): SspParser

def ensuring(cond: Boolean): SspParser

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def expressionDirective[T](p: Parser[T]): Parser[Text]

def expressionDirective(name: String): Parser[Text]

val expressionFragment: Parser[ExpressionFragment]

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

def finalize(): Unit

def forExpression: Parser[ForFragment]

def formatted(fmtstr: String): String

def getAttribute(in: String): AttributeFragment

final def getClass(): Class[_]

def getPageFragments(in: String): List[PageFragment]

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

def guarded[T, U](p1: Parser[T], p2: Parser[U]): Parser[U]