ClauseTreeParse

Type Members

type InstrumentCallback = (Parser[_, Char, String], Int, () ⇒ Parsed[_, Char, String]) ⇒ Unit

Definition Classes
Parser
case class NamedFunction[T, V](f: (T) ⇒ V, name: String) extends (T) ⇒ V with Product with Serializable

Definition Classes
Helpers

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
val Digits: NamedFunction[Char, Boolean]

Definition Classes
Helpers
val Whitespace: NamedFunction[Char, Boolean]

Definition Classes
Helpers
final def asInstanceOf[T0]: T0

Definition Classes
Any
val charSeq: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val clause: Parser[Clause[Any], Char, String]
val clauseOperator: Parser[BinaryOperator, Char, String]

Definition Classes
Operators
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val closeBracket: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val closeParen: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val closeParenLah: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val dMHms: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val date: Parser[DateTime, Char, String]

Definition Classes
BasicParsers
val dateFormat: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val dateTimeFormatter: DateTimeFormatter

Definition Classes
Helpers
val digits: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val double: Parser[Double, Char, String]

Definition Classes
BasicParsers
val element: fastparse.noApi.Parser[Any]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val eqOperator: Parser[EqualityOperator, Char, String]

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

Definition Classes
AnyRef → Any
def fail(f: Failure[Char, String], index: Int, traceParsers: Set[Parser[_, Char, String]], cut: Boolean): Failure[Char, String]

Definition Classes
ParserResults
def failMore(f: Failure[Char, String], index: Int, logDepth: Int, traceParsers: Set[Parser[_, Char, String]], cut: Boolean): Failure[Char, String]

Definition Classes
ParserResults
val field: Parser[String, Char, String]
def finalize(): Unit

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

Definition Classes
AnyRef → Any
val integer: Parser[Int, Char, String]

Definition Classes
BasicParsers
val integral: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def list[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[List[T]]

Definition Classes
BasicParsers
val logicOperator: Parser[BinaryOperator with LogicOperator, Char, String]

Definition Classes
Operators
val logicOperatorSection: fastparse.noApi.Parser[BinaryOperator with LogicOperator]
val matchingOperator: Parser[MatchingOperator, Char, String]

Definition Classes
Operators
def mergeTrace(traceIndex: Int, lhs: Set[Parser[_, Char, String]], rhs: Set[Parser[_, Char, String]]): Set[Parser[_, Char, String]]

Definition Classes
ParserResults
def monospaced[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[T]

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val numericOperator: Parser[BinaryOperator, Char, String]

Definition Classes
Operators
val oneSpaceAtLeast: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
def opPred: Int

Definition Classes
Parser → Precedence
def opWrap(s: Precedence): String

Attributes
protected
Definition Classes
Precedence
val openBracket: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val openParen: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val openParenLah: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
def parenBlock[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[Vector[T]]

Definition Classes
BasicParsers
def parse(input: String, index: Int, instrument: InstrumentCallback): Parsed[ClauseTree, Char, String]

Definition Classes
Parser
def parseDate(date: String): DateTime

Definition Classes
Helpers
def parseInput(input: ParserInput[Char, String], index: Int, instrument: InstrumentCallback): Parsed[ClauseTree, Char, String]

Definition Classes
Parser
def parseIterator(input: Iterator[String], index: Int, instrument: InstrumentCallback)(implicit ct: ClassTag[Char]): Parsed[ClauseTree, Char, String]

Definition Classes
Parser
def parseRec(cfg: StringParseCtx, index: Int): StringMutable[ClauseTree]

Definition Classes
ClauseTreeParse → Parser
def quoted[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[String]

Definition Classes
BasicParsers
implicit val reprOps: ReprOps[Char, String]

Definition Classes
Parser
val seconds: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
def shortTraced: Boolean

Definition Classes
Parser
val space: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
def success[T](s: Success[_, Char, String], value: T, index: Int, traceParsers: Set[Parser[_, Char, String]], cut: Boolean): Success[T, Char, String]

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

Definition Classes
AnyRef
val time: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
val tz: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers
def unapply(input: String): Option[ClauseTree]

Definition Classes
Parser
val value: fastparse.noApi.Parser[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( ... )
val year: fastparse.all.Parser[Unit]

Definition Classes
BasicParsers

Related Doc: package parser

object ClauseTreeParse extends StringParser[ClauseTree] with Operators with BasicParsers with Product with Serializable

Type Members

type InstrumentCallback = (Parser[_, Char, String], Int, () ⇒ Parsed[_, Char, String]) ⇒ Unit

case class NamedFunction[T, V](f: (T) ⇒ V, name: String) extends (T) ⇒ V with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val Digits: NamedFunction[Char, Boolean]

val Whitespace: NamedFunction[Char, Boolean]

final def asInstanceOf[T0]: T0

val charSeq: fastparse.all.Parser[Unit]

val clause: Parser[Clause[Any], Char, String]

val clauseOperator: Parser[BinaryOperator, Char, String]

def clone(): AnyRef

val closeBracket: fastparse.all.Parser[Unit]

val closeParen: fastparse.all.Parser[Unit]

val closeParenLah: fastparse.all.Parser[Unit]

val dMHms: fastparse.all.Parser[Unit]

val date: Parser[DateTime, Char, String]

val dateFormat: fastparse.all.Parser[Unit]

val dateTimeFormatter: DateTimeFormatter

val digits: fastparse.all.Parser[Unit]

val double: Parser[Double, Char, String]

val element: fastparse.noApi.Parser[Any]

final def eq(arg0: AnyRef): Boolean

val eqOperator: Parser[EqualityOperator, Char, String]

def equals(arg0: Any): Boolean

def fail(f: Failure[Char, String], index: Int, traceParsers: Set[Parser[_, Char, String]], cut: Boolean): Failure[Char, String]

def failMore(f: Failure[Char, String], index: Int, logDepth: Int, traceParsers: Set[Parser[_, Char, String]], cut: Boolean): Failure[Char, String]

val field: Parser[String, Char, String]

def finalize(): Unit

final def getClass(): Class[_]

val integer: Parser[Int, Char, String]

val integral: fastparse.all.Parser[Unit]

final def isInstanceOf[T0]: Boolean

def list[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[List[T]]

val logicOperator: Parser[BinaryOperator with LogicOperator, Char, String]

val logicOperatorSection: fastparse.noApi.Parser[BinaryOperator with LogicOperator]

val matchingOperator: Parser[MatchingOperator, Char, String]

def mergeTrace(traceIndex: Int, lhs: Set[Parser[_, Char, String]], rhs: Set[Parser[_, Char, String]]): Set[Parser[_, Char, String]]

def monospaced[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val numericOperator: Parser[BinaryOperator, Char, String]

val oneSpaceAtLeast: fastparse.all.Parser[Unit]

def opPred: Int

def opWrap(s: Precedence): String

val openBracket: fastparse.all.Parser[Unit]

val openParen: fastparse.all.Parser[Unit]

val openParenLah: fastparse.all.Parser[Unit]

def parenBlock[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[Vector[T]]

def parse(input: String, index: Int, instrument: InstrumentCallback): Parsed[ClauseTree, Char, String]

def parseDate(date: String): DateTime

def parseInput(input: ParserInput[Char, String], index: Int, instrument: InstrumentCallback): Parsed[ClauseTree, Char, String]

def parseIterator(input: Iterator[String], index: Int, instrument: InstrumentCallback)(implicit ct: ClassTag[Char]): Parsed[ClauseTree, Char, String]

def parseRec(cfg: StringParseCtx, index: Int): StringMutable[ClauseTree]

def quoted[T](p: fastparse.all.Parser[T]): fastparse.all.Parser[String]

implicit val reprOps: ReprOps[Char, String]

val seconds: fastparse.all.Parser[Unit]

def shortTraced: Boolean

val space: fastparse.all.Parser[Unit]

def success[T](s: Success[_, Char, String], value: T, index: Int, traceParsers: Set[Parser[_, Char, String]], cut: Boolean): Success[T, Char, String]

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

val time: fastparse.all.Parser[Unit]

val tz: fastparse.all.Parser[Unit]

def unapply(input: String): Option[ClauseTree]

val value: fastparse.noApi.Parser[Any]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val year: fastparse.all.Parser[Unit]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from Operators