TerminatorParseEv

Instance Constructors

new TerminatorParseEv(expr: CompiledExpression[String], isLengthKindDelimited: Boolean, ignoreCase: Boolean, trd: TermRuntimeData)

Type Members

type State = ParseOrUnparseState

Definition Classes
Evaluatable

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[Array[DFADelimiter]]

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

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): Array[DFADelimiter]

Attributes
protected
Definition Classes
DelimiterParseEv → Evaluatable
final def constValue: Array[DFADelimiter]

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

Definition Classes
ExprEvalMixin → ContentValueReferencedElementInfoMixin
val converter: ListOfStringLiteralBase

Definition Classes
TerminatorParseEv → DelimiterEvMixin
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[String], state: ParseOrUnparseState): String

Attributes
protected
Definition Classes
ExprEvalMixin
def evalAndConvert(state: ParseOrUnparseState): List[String]

Attributes
protected
Definition Classes
DelimiterEvMixin
final def evaluate(state: State): Array[DFADelimiter]

Definition Classes
Evaluatable
val expr: CompiledExpression[String]

Definition Classes
DelimiterParseEv → DelimiterEvMixin → ExprEvalMixin
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def getCachedOrComputeAndCache(state: State): Array[DFADelimiter]

Attributes
protected
Definition Classes
InfosetCachedEvaluatable
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 isKnownNonEmpty: Boolean

Definition Classes
DelimiterEvMixin
final def maybeConstant: Maybe[Array[DFADelimiter]]

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[Array[DFADelimiter]]

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

Important - Evalutables MUST declare all evaluatables they depend on.
Important - Evalutables MUST declare all evaluatables they depend on. But only those they directly depend on. (Not the dependents of the dependents...)

Definition Classes
DelimiterParseEv → Evaluatable
final def synchronized[T0](arg0: ⇒ T0): T0

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

Definition Classes
DelimiterEvMixin
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
val trd: TermRuntimeData

Definition Classes
DelimiterParseEv → DelimiterEvMixin
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

class TerminatorParseEv extends DelimiterParseEv

Instance Constructors

new TerminatorParseEv(expr: CompiledExpression[String], isLengthKindDelimited: Boolean, ignoreCase: Boolean, trd: TermRuntimeData)

Type Members

type State = ParseOrUnparseState

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[Array[DFADelimiter]]

final def compile(state: CompileState): Maybe[Array[DFADelimiter]]

def compute(state: ParseOrUnparseState): Array[DFADelimiter]

final def constValue: Array[DFADelimiter]

final def contentReferencedElementInfos: Set[DPathElementCompileInfo]

val converter: ListOfStringLiteralBase

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[String], state: ParseOrUnparseState): String

def evalAndConvert(state: ParseOrUnparseState): List[String]

final def evaluate(state: State): Array[DFADelimiter]

val expr: CompiledExpression[String]

def finalize(): Unit

def getCachedOrComputeAndCache(state: State): Array[DFADelimiter]

final def getClass(): Class[_]

def hashCode(): Int

final def isCompiled: Boolean

final def isConstant: Boolean

final def isInstanceOf[T0]: Boolean

final def isKnownNonEmpty: Boolean

final def maybeConstant: Maybe[Array[DFADelimiter]]

def maybeUseUnparserMode: Maybe[EvalMode]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def optConstant: Option[Array[DFADelimiter]]

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

val trd: TermRuntimeData

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 DelimiterParseEv

Inherited from DelimiterEvMixin[Array[DFADelimiter]]

Inherited from ExprEvalMixin[String]

Inherited from ContentValueReferencedElementInfoMixin

Inherited from DoSDEMixin

Inherited from InfosetCachedEvaluatable[Array[DFADelimiter]]

Inherited from Evaluatable[Array[DFADelimiter]]

Inherited from Serializable

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped