EvaluatableConvertedExpression

Instance Constructors

new EvaluatableConvertedExpression(expr: CompiledExpression[ExprType], converter: Converter[ExprType, ConvertedType], rd: RuntimeData)

Type Members

type State = ParseOrUnparseState

Definition Classes
Evaluatable

Abstract Value Members

abstract def getCachedOrComputeAndCache(state: State): ConvertedType

Attributes
protected
Definition Classes
Evaluatable

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( ... )
final def compile(): Maybe[ConvertedType]

Definition Classes
Evaluatable
final def compile(state: CompileState): Maybe[ConvertedType]

Compile an Ev to see if it is a constant at compilation time.
Compile an Ev to see if it is a constant at compilation time. This is determined by actually evaluating it, passing a special CompileState that errors out when data access to runtime-valued data is attempted.

Definition Classes
Evaluatable
def compute(state: ParseOrUnparseState): ConvertedType

Attributes
protected
Definition Classes
EvaluatableConvertedExpressionMixin
final def constValue: ConvertedType

Definition Classes
Evaluatable
Annotations
@inline()
final def contentReferencedElementInfos: Set[DPathElementCompileInfo]

Definition Classes
ExprEvalMixin → ContentValueReferencedElementInfoMixin
val converter: Converter[ExprType, ConvertedType]

Definition Classes
EvaluatableConvertedExpression → EvaluatableConvertedExpressionMixin
def dafName(local: String): GlobalQName

Convenience method
Convenience method
Use by way of override lazy val qName = dafName("foobar")

Attributes
protected
Definition Classes
Evaluatable
final def doSDE(e: Throwable, state: ParseOrUnparseState): Nothing

Attributes
protected
Definition Classes
DoSDEMixin
final def ensureCompiled: Unit

Definition Classes
Evaluatable
Annotations
@inline()
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
final def eval(expr: CompiledExpression[ExprType], state: ParseOrUnparseState): ExprType

Attributes
protected
Definition Classes
ExprEvalMixin
final def evaluate(state: State): ConvertedType

Definition Classes
Evaluatable
val expr: CompiledExpression[ExprType]

Definition Classes
EvaluatableConvertedExpression → ExprEvalMixin
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 isCompiled: Boolean

Definition Classes
Evaluatable
Annotations
@inline()
final def isConstant: Boolean

Definition Classes
Evaluatable
Annotations
@inline()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def maybeConstant: Maybe[ConvertedType]

Preferred for use in the runtime.
Preferred for use in the runtime.

Definition Classes
Evaluatable
Annotations
@inline()
def maybeUseUnparserMode: Maybe[EvalMode]

Override if this evaluatable needs to use a different evaluate mode for unparsing.
Override if this evaluatable needs to use a different evaluate mode for unparsing.
The only example of this (as of this comment being written) is LengthEv

Attributes
protected
Definition Classes
Evaluatable
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def optConstant: Option[ConvertedType]

Schema compiler wants to use map call, so we need a scala option type for that.
Schema compiler wants to use map call, so we need a scala option type for that. So this variant supplies that.

Definition Classes
Evaluatable
Annotations
@inline()
lazy val qName: NamedQName

QName to be associated with this evaluatable.
QName to be associated with this evaluatable.
If the Evaluatable is for a DFDL property this should be dfdl:propertyName e.g., dfdl:terminator, with the prefix DFDL being the prefix associated with the DFDL namespace.
If the Evaluatable is for some other computation, e.g., for the CharsetEncoder. Then daf:encoder or other useful identifier.
This QName is used in the XML representation of these Evaluatables, if they are to be displayed, which is mostly for various debug purposes.

Definition Classes
Evaluatable
val rd: RuntimeData

Attributes
protected
Definition Classes
Evaluatable
lazy val runtimeDependencies: Nil.type

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

Definition Classes
AnyRef
final def toBriefXML(depth: Int = 1): String

Definition Classes
EvaluatableConvertedExpressionMixin
def toPseudoXML(cache: EvalCache): String

Creates an XML-like string representation.
Creates an XML-like string representation.
Looks like an attribute definition, but the value part may contain XML-element-like syntax. If so it is either escaped with CDATA bracketing (preferred), or if there are quotes in it, then it is escapified meaning " < etc.
Avoids inserting single quotes (aka apos) so that those can be used surrounding this at a higher level.

Definition Classes
Evaluatable
def toSDE(e: Diagnostic, state: ParseOrUnparseState): Nothing

Attributes
protected
Definition Classes
Evaluatable
def toString(): String

Definition Classes
Evaluatable → AnyRef → Any
final def valueReferencedElementInfos: Set[DPathElementCompileInfo]

Definition Classes
ExprEvalMixin → ContentValueReferencedElementInfoMixin
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( ... )

Related Doc: package processors

abstract class EvaluatableConvertedExpression[ExprType <: AnyRef, +ConvertedType <: AnyRef] extends Evaluatable[ConvertedType] with EvaluatableConvertedExpressionMixin[ExprType, ConvertedType]

Instance Constructors

new EvaluatableConvertedExpression(expr: CompiledExpression[ExprType], converter: Converter[ExprType, ConvertedType], rd: RuntimeData)

Type Members

type State = ParseOrUnparseState

Abstract Value Members

abstract def getCachedOrComputeAndCache(state: State): ConvertedType

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def compile(): Maybe[ConvertedType]

final def compile(state: CompileState): Maybe[ConvertedType]

def compute(state: ParseOrUnparseState): ConvertedType

final def constValue: ConvertedType

final def contentReferencedElementInfos: Set[DPathElementCompileInfo]

val converter: Converter[ExprType, ConvertedType]

def dafName(local: String): GlobalQName

final def doSDE(e: Throwable, state: ParseOrUnparseState): Nothing

final def ensureCompiled: Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def eval(expr: CompiledExpression[ExprType], state: ParseOrUnparseState): ExprType

final def evaluate(state: State): ConvertedType

val expr: CompiledExpression[ExprType]

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isCompiled: Boolean

final def isConstant: Boolean

final def isInstanceOf[T0]: Boolean

final def maybeConstant: Maybe[ConvertedType]

def maybeUseUnparserMode: Maybe[EvalMode]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def optConstant: Option[ConvertedType]

lazy val qName: NamedQName

val rd: RuntimeData

lazy val runtimeDependencies: Nil.type

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

final def toBriefXML(depth: Int = 1): String

def toPseudoXML(cache: EvalCache): String

def toSDE(e: Diagnostic, state: ParseOrUnparseState): Nothing

def toString(): String

final def valueReferencedElementInfos: Set[DPathElementCompileInfo]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from EvaluatableConvertedExpressionMixin[ExprType, ConvertedType]

Inherited from ExprEvalMixin[ExprType]

Inherited from ContentValueReferencedElementInfoMixin

Inherited from DoSDEMixin

Inherited from Evaluatable[ConvertedType]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped