expr

Type Members

1. case class AExpr2(a: Expr, op: String, b: Expr) extends Expr with Product with Serializable

   

   type-aware arithmetic expressions of the form "a OP b" - on various types, including json, strings, arrays etc

2. case class AExprFunc(expr: String, parms: List[P]) extends Expr with Product with Serializable

   

   a "function-like" call: - built-in functions, - msg functions (exec'd in same engine, sync) - domain functions / class members

3. case class AExprIdent(start: String, rest: List[P] = Nil) extends Expr with Product with Serializable

   

   resolving qualified identifier, including arrays, ranges, json docs etc

   resolving qualified identifier, including arrays, ranges, json docs etc

   start

   qualified expr a.b.c - this is used in places as such... don't replace with just a

   rest

   the rest from the first []

4. case class BCMP1(a: BoolExpr, op: String, b: BoolExpr) extends BoolExpr with Product with Serializable

   

   composed boolean expression

5. case class BCMP2(a: Expr, op: String, b: Expr) extends BoolExpr with Product with Serializable

   

   simple boolean expression

6. case class BCMPConst(a: String) extends BoolExpr with Product with Serializable

   

   const boolean expression

7. case class BCMPNot(a: BoolExpr) extends BoolExpr with Product with Serializable

   

   negated boolean expression

8. case class BCMPSingle(a: Expr) extends BoolExpr with Product with Serializable

   

   single term bool expression

9. case class BExprBlock(a: BoolExpr) extends BoolExpr with Product with Serializable

   

   boolean expression block - show the () when printing

10. case class BExprResult(value: Boolean, a: Option[P] = None, b: Option[P] = None) extends Product with Serializable

    

    details about the result: what values were involved?

11. case class BlockExpr(ex: Expr) extends Expr with Product with Serializable

    

    a block i.e.

    a block i.e. ( expr )

12. abstract class BoolExpr extends Expr with HasDsl

    

    boolean expressions

13. case class CExpr[T](ee: T, ttype: WType = WTypes.wt.EMPTY) extends Expr with Product with Serializable

    

    constant expression - similar to PValue

14. case class CExprNull() extends Expr with Product with Serializable

    

    a function

15. class DieselExprException extends RuntimeException

    

    marker exception class for expr - understood by AST engine and treated nicer than a random exception

16. trait ECtx extends AnyRef

    

    A map-like context of attribute values, used by the Diesel engine.

    A map-like context of attribute values, used by the Diesel engine. Also, most expression evaluators work within a context.

    These contexts are hierarchical, with inheritance and overwriting. Each engine has a root context. There are also scope contexts (which don't allow propagation of values) etc

    They also capture a spec environment: a list of specs (could be drafts or a specific version)

    Also, they have an optional domain - this is used to source values and functions and other objects for expressions. Normally, the domain is set by the engine at the root context level.

    todo keep a ref to the original specs, to get more details, so for the duration of this context, the configuration is the right version

17. abstract class Expr extends WFunc with HasDsl with CanHtml

    

    an expression

18. trait ExprParser extends RegexParsers

    

    expressions parser.

    expressions parser. this is a trait you can mix in your other DSL parsers, see SimpleExprParser for a concrete implementation

    See http://specs.razie.com/wiki/Story:expr_story for possible expressions and examples

19. case class ExprRange(start: Expr, end: Option[Expr]) extends Expr with Product with Serializable

    

    a range like 1..4 or ..5 etc

20. trait HasDsl extends AnyRef

    

    element has DSL form

    element has DSL form

    deserialization is assumed via parser

    the idea is that all activities would have an external DSL form as well and can serialize themselves in that form

    serialize the DEFINITION only - not including states/values

21. case class JArrExpr(ex: List[Expr]) extends Expr with Product with Serializable

    

    a json array

22. case class JBlockExpr(ex: List[(String, Expr)]) extends Expr with Product with Serializable

    

    a json document block: - you may or may not use quotes for names -

23. case class JSSExpr(s: String) extends Expr with Product with Serializable

    

    a js expression js:a.b js:{...}

24. case class LambdaFuncExpr(argName: String, ex: Expr, parms: List[P] = Nil) extends Expr with Product with Serializable

    

    a "function" call: built-in functions, msg functions (exec'd in same engine, sync)

25. case class PAS(left: AExprIdent, right: Expr) extends CanHtml with Product with Serializable

    

    assignment - needed because the left side is more than just a val

26. case class SCExpr(s: String) extends Expr with Product with Serializable

    

    a scala expression sc:a.b sc:{...}

27. class ScopeECtx extends SimpleECtx

    

    context for an internal scope - parent is scope or Eng

    context for an internal scope - parent is scope or Eng

    todo when saving a context, do I save children too?

    todo when loading context, how do I reover active scope contexts

28. class SimpleECtx extends ECtx

    

    a context - LIST, use to see speed of list

29. class SimpleExprParser extends ExprParser

    

    A simple parser for our simple specs

    A simple parser for our simple specs

    DomParser is the actual Diesel/Dom parser. We extend from it to include its functionality and then we add its parsing rules with withBlocks()

30. class StaticECtx extends SimpleECtx

    

    static context will delegate updates to parent - good as temporary override when evaluating a message

31. class StaticECtxOverride extends SimpleECtx

    

    static context will delegate updates to parent - good as temporary override when evaluating a message

32. trait WFunc extends AnyRef

    

    Basic executable/actionable interface.

    Basic executable/actionable interface. These process a default input value and return a Typed output value.

    They are also invoked in a context - a set of objects in a certain role.

    There are two major branches: WFunc and WfActivity. An action is a workflow specific thing and is aware of next actions, state of execution whatnot. It also does something so it's derived from WFunc.

    WFunc by itself only does something and is not stateful. Most activities are like that.