DomParser

abstract def apply(input: String): BaseAstNode

abstract def line: PS

a line of wiki (to CR/LF)

abstract def lines: PS

a sequence of lines

abstract def optline: PS

an optional line

abstract def realm: String

provide a realm

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def CRLF1: DomParser.P

def CRLF2: DomParser.P

def CRLF3: DomParser.P

def NADA: DomParser.P

object NoSuccess

def OPS1: Parser[String]

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]]

def accessors: Parser[List[diesel.dom.RDOM.P]]

def addToDom(c: Any): LazyAstNode[DSpec, DUser]

add a domain element to the topic

def afloat: Parser[String]

def afunc: Parser[Expr]

def aident: Parser[AExprIdent]

def aidentExpr: Parser[AExprIdent]

def aidentaccess: Parser[AExprIdent]

def aint: Parser[String]

def arg: Parser[(String, String)]

def arg0: Parser[(String, String)]

def arg2: Parser[(String, String)]

final def asInstanceOf[T0]: T0

def assRole: Parser[(String, String)]

assoc : role

def attrs: Parser[List[diesel.dom.RDOM.P]]

optional attributes

def bConst: Parser[BoolExpr]

true or false constants

def bfactor1: Parser[BoolExpr]

def bfactor2: Parser[BoolExpr]

def boolConst: Parser[Expr]

def bterm1: Parser[BoolExpr]

def bvalue: Parser[BoolExpr]

single value expressions, where != 0 is true and != null is true

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]

def clone(): AnyRef

def clsMatch: Parser[(String, String, List[PM])]

pattern match for ent.met

def clsMet: Parser[(String, String, List[diesel.dom.RDOM.P])]

ent.met (parms)

val comOperators: Regex

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

def cond: Parser[BoolExpr]

def defline: Parser[F]

msg name (a,b) : String

def df: Parser[BoolExpr]

def domainBlocks: Parser[BaseAstNode]

def eblock: Parser[Expr]

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

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

def eq: Parser[BoolExpr]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def escaped: PS

def escaped1: PS

def escaped2: PS

def expr: Parser[Expr]

main entry point for an expression

def expr2: Parser[Expr]

def exprAND: Parser[Expr]

def exprAS: Parser[Expr]

def exprCMP: Parser[Expr]

def exprMAP: Parser[Expr]

def exprMULT: Parser[Expr]

def exprOR: Parser[Expr]

def exprPLUS: Parser[Expr]

def exregex: Parser[Expr]

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

def fiddleBlocks(wpath: String): Parser[Product with Serializable with HasPosition with CanHtml]

this one used for fiddles, see FiddleParser

def fiddleLines(wpath: String): Parser[List[Product with Serializable]]

def finalize(): Unit

def flowexpr: Parser[FlowExpr]

final def getClass(): Class[_]

def gt: Parser[BoolExpr]

def gte: Parser[BoolExpr]

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

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

def hashCode(): Int

def ident: Parser[String]

a regular ident but also something in single quotes '[email protected] and - is a good ident eh'

final def isInstanceOf[T0]: Boolean

def jarray: Parser[Expr]

def jexpr: Parser[Expr]

def jnull: Parser[Expr]

def jnvp: Parser[(String, Expr)]

def jobj: Parser[Expr]

def jother: Parser[Expr]

def jsexpr1: Parser[Expr]

def jsexpr2: Parser[Expr]

def jsexpr4: Parser[Expr]

def jsonIdent: Parser[String]

allow JSON ids with double quotes, single quotes or no quotes

def jsregex: P

def justAttrs: Parser[List[PAS]]

assoc : role

def lambda: Parser[Expr]

def lastLine: PS

def lazys(f: (StrAstNode, FoldingContext[DSpec, DUser]) ⇒ StrAstNode): LazyAstNode[DSpec, DUser]

def like: Parser[BoolExpr]

def linemock(wpath: String): Parser[EMock]

this one used for fiddles, see FiddleParser

def linemsg(wpath: String): Parser[EMsg]

this one used for fiddles, see FiddleParser

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

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

def lt: Parser[BoolExpr]

def lte: Parser[BoolExpr]

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

val moreBlocks: ListBuffer[Parser[BaseAstNode]]

val moreDotProps: ListBuffer[Parser[BaseAstNode]]

val moreWikiProps: ListBuffer[Parser[BaseAstNode]]

def msgline: Parser[F]

def name (a,b) : String

def msgterm1: Parser[FlowExpr]

def multilineStrConst: Parser[Expr]

final def ne(arg0: AnyRef): Boolean

def neq: Parser[BoolExpr]

def noFiddleB: Parser[Unit]

def noptargs: Parser[List[(String, String)]]

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

def notbfactor1: Parser[BoolExpr]

final def notify(): Unit

final def notifyAll(): Unit

def numConst: Parser[Expr]

def oneStatic: DomParser.P

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

def optAssertExprs: Parser[List[BoolExpr]]

todo is not working

def optAttrs: Parser[List[diesel.dom.RDOM.P]]

optional attributes

def optBlock: Parser[List[Executable]]

def optClassBody: Parser[List[F]]

def optComment: Parser[String]

def optKinds: Parser[Option[String]]

def optScript: PS

optional script body

def optType: Parser[WType]

:<>type[kind]* <> means it's a ref, not ownership * means it's a list

def optargs: Parser[List[(String, String)]]

def orexpr: Parser[BoolExpr]

def ows: Parser[Option[String]]

def pArrow: Parser[String]

def pComment: Parser[String]

def panno: PS

.anno (params)

def parblock: Parser[FlowExpr]

def parexpr: Parser[FlowExpr]

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 parterm1: Parser[FlowExpr]

def pasattr: Parser[PAS]

parm assignment, left side can be a[5].name, useful in a $val

def pasattrs: Parser[List[PAS]]

def passert: PS

.expect object.func (a,b)

def passoc: PS

.assoc name a:role -> z:role

def pattr: Parser[diesel.dom.RDOM.P]

parm definition / assignment

def pblock: PS

optional script body

def pcallattr: Parser[diesel.dom.RDOM.P]

def pcallattrs: Parser[List[diesel.dom.RDOM.P]]

simple ident = expr assignemtn when calling

def pclass: PS

.class X [T] (a,b:String) extends A,B {}

def pdef: PS

.func name (a,b) : String

def pexpect: PS

.expect object.func (a,b)

def pflow: PS

.flow e.a => expr

def pgen: Parser[EMap]

def pgenStep: Parser[EMap]

- text - i.e.

def pgenText: Parser[EMap]

- text - i.e.

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

def pif: Parser[EIf]

def pifc: Parser[EIf]

def pifm: Parser[EIf]

def pmatch: PS

.match a.role (attrs) // not used

def pmatchattr: Parser[PM]

def pmatchattrE: Parser[PM]

condition - bool expr

def pmatchattrM: Parser[PM]

name:type[kind] OPerator xx means it's a list

def pmsg: PS

.msg object.func (a,b)

def pobject: PS

def pos(k: Keyw): Some[EPos]

def pos(k: Keyw, ctx: FoldingContext[DSpec, DUser]): Some[EPos]

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

def psend: PS

.receive object.func (a,b)

def pterm1: Parser[Expr]

def pval: PS

.option name:type=value

def pwhen: PS

.when <tags> a.role (attrs) => z.role (attrs) tags are optional and could be rule, mock, model, impl etc - rule is the default for execution - mock is for mocks - others like model or impl are specific

def qclsMet: Parser[(String, String, String)]

ent.met - qualified ent so at least two elements

def qident: Parser[String]

qualified idents, .

def qlident: Parser[List[String]]

def qlidentDiesel: Parser[List[String]]

def qualified(qcm: List[String]): (String, String, String)

p.a.ent.met - qualified ent so at least two elements

def realmqlident: Parser[List[String]]

qualified idents, .

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

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 repN[T](num: Int, p: ⇒ Parser[T]): Parser[List[T]]

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

def scall: Parser[Executable]

def scexpr1: Parser[Expr]

def scexpr2: Parser[Expr]

def seqexpr: Parser[FlowExpr]

def skipWhitespace: Boolean

def sline(tag: String): PS

def sline: PS

def slines: Parser[StrAstNode]

def slinesUntil(tag: String): Parser[StrAstNode]

def soptline(tag: String): PS

def soptline: PS

def sstatic(tag: String): PS

def sstatic: PS

def statement: Parser[Executable]

def static: DomParser.P

def strConst: Parser[Expr]

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

def svalue: Parser[Executable]

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

def toString(): String

def unquote(s: String): String

def valueDef: Parser[diesel.dom.RDOM.P]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val whiteSpace: Regex

def withBlocks(p: Parser[BaseAstNode]): ParserBase

def withDotProp(p: Parser[BaseAstNode]): ParserBase

def withWikiProp(p: Parser[BaseAstNode]): ParserBase

def ws: Regex

def xCRLF1: PS

def xCRLF2: PS

def xCRLF3: PS

def xNADA: PS

def xpath: Parser[String]

def xpident: Parser[Expr]

def xstatic: PS