LiteralNilDelimitedEndOfData

Instance Constructors

new LiteralNilDelimitedEndOfData(eb: ElementBase)

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 LV[T](sym: Symbol)(body: ⇒ T): OOLAGValue[T]

Attributes
protected
Definition Classes
OOLAGHost
final def SDE(str: String, args: Any*): Nothing

Definition Classes
Gram
final def SDW(warnID: WarnID, str: String, args: Any*): Unit

Definition Classes
Gram
final def areLogging(lvl: Type): Boolean

Definition Classes
Logging
final def asInstanceOf[T0]: T0

Definition Classes
Any
final def assuming(pred: Boolean): Unit

Definition Classes
OOLAGHost
def checkDelimiterDistinctness(escapeSchemeKind: EscapeKind, optPadChar: Option[String], optEscChar: Option[String], optEscEscChar: Option[String], optEscBlkStart: Option[String], optEscBlkEnd: Option[String], terminatingMarkup: Seq[String], context: ThrowsSDE): Unit

Definition Classes
StringDelimBase
final def checkErrors: Unit

Definition Classes
OOLAGHost
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
lazy val cname: String

Definition Classes
StringDelimited
final val context: SchemaComponent

Definition Classes
Gram
final var currentOVList: Seq[OOLAGValueBase]

Definition Classes
OOLAGHost
lazy val diagnosticDebugName: String

Definition Classes
NamedMixinBase
def diagnostics: Seq[Diagnostic]

Definition Classes
OOLAGHost
def doLogging(lvl: Type, msg: String, args: Seq[Any]): Unit

Attributes
protected
Definition Classes
Logging
final def eBase: ElementBase

Attributes
protected
Definition Classes
Padded → PaddingInfoMixin
lazy val eName: String

Definition Classes
StringDelimited
val eb: ElementBase
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def error(th: Diagnostic): Unit

Definition Classes
OOLAGHost
final def errors: Seq[Diagnostic]

Definition Classes
OOLAGHost
lazy val es: Option[DFDLEscapeScheme]

Definition Classes
StringDelimited
lazy val escapeSchemeParseEvOpt: Maybe[EscapeSchemeParseEv]

Definition Classes
StringDelimited
lazy val escapeSchemeUnparseEvOpt: Maybe[EscapeSchemeUnparseEv]

Definition Classes
StringDelimited
lazy val fieldDFAParseEv: FieldDFAParseEv

Definition Classes
StringDelimited
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
val forWhat: ParserOrUnparser

Definition Classes
Gram
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getDiagnostics: Seq[Diagnostic]

Definition Classes
OOLAGHost → WithDiagnostics
def getLogWriter(): LogWriter

Definition Classes
Logging
final def getLoggingLevel(): Type

Definition Classes
Logging
final def hasNoParser: Parser

Attributes
protected
Definition Classes
Gram
final def hasNoUnparser: Unparser

Attributes
protected
Definition Classes
Gram
final def hasOOLAGRootSetup: Boolean

Definition Classes
OOLAGHost
lazy val isDelimRequired: Boolean

Definition Classes
LiteralNilDelimitedEndOfData → StringDelimited
def isEmpty: Boolean

Definition Classes
Terminal → Gram
def isError: Boolean

Definition Classes
OOLAGHost → WithDiagnostics
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val justificationPad: Type

Definition Classes
PaddingInfoMixin
lazy val justificationTrim: Type

parsingPadChar is the pad character for parsing unparsingPadChar is the pad character for unparsing These are always carried as MaybeChar.
parsingPadChar is the pad character for parsing unparsingPadChar is the pad character for unparsing These are always carried as MaybeChar.
We need both, because in the same schema you can have textPadKind="padChar" but textTrimKind="none", so there can't be just one pad char object if it is to carry information about both whether or not a pad character is to be used, and the value.

Definition Classes
PaddingInfoMixin
lazy val leftPaddingOpt: Option[TextPaddingParser]

Definition Classes
StringDelimited
final macro def log(lvl: Type, msg: String, args: Any*): Unit

Definition Classes
Logging
lazy val logID: String

Definition Classes
Logging → Identity
var logLevel: Maybe[Type]

Definition Classes
Logging
var logWriter: Maybe[LogWriter]

Definition Classes
Logging
final def maybeParser: Maybe[Parser]

Definition Classes
Gram
final def maybeUnparser: Maybe[Unparser]

Definition Classes
Gram
final val nArgs: Args

Definition Classes
OOLAGHostImpl → OOLAGHost
def name: String

Definition Classes
NamedGram → Gram
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final lazy val oolagContext: OOLAGHost

Definition Classes
OOLAGHost
final def oolagContextViaArgs: Some[OOLAGHost]

Attributes
protected
Definition Classes
OOLAGHostImpl → OOLAGHost
def oolagError(th: Diagnostic): Unit

Attributes
protected
Definition Classes
OOLAGHost
final def oolagParent: OOLAGHost

Attributes
protected
Definition Classes
OOLAGHost
def oolagWarn(th: Diagnostic): Unit

Attributes
protected
Definition Classes
OOLAGHost
lazy val parser: Parser

Provides parser.
Provides parser.
Required to examine child parsers, and optimize itself out by propagating NadaParser if there is no parser.

Definition Classes
LiteralNilDelimitedEndOfData → StringDelimited → Gram
lazy val parsingPadChar: MaybeChar

parsingPadChar is the pad character for parsing unparsingPadChar is the pad character for unparsing These are always carried as MaybeChar.
parsingPadChar is the pad character for parsing unparsingPadChar is the pad character for unparsing These are always carried as MaybeChar.
We need both, because in the same schema you can have textPadKind="padChar" but textTrimKind="none", so there can't be just one pad char object if it is to carry information about both whether or not a pad character is to be used, and the value.

Definition Classes
PaddingInfoMixin
lazy val path: String

Definition Classes
Gram → OOLAGHost
final def requiredEvaluations(lv: OOLAGValueBase): Unit

Attributes
protected
Definition Classes
OOLAGHost
final def requiredEvaluations(arg: ⇒ Any): Unit

Attributes
protected
Definition Classes
OOLAGHost
def setLogWriter(lw: LogWriter): Unit

Definition Classes
Logging
def setLoggingLevel(level: Type): Unit

Definition Classes
Logging
final def setOOLAGContext(oolagContextArg: OOLAGHost): Unit

Definition Classes
OOLAGHost
lazy val stringTruncationType: Type

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

Definition Classes
AnyRef
val textDelimitedParser: TextDelimitedParserBase

Definition Classes
StringDelimited
def toString(): String

Definition Classes
StringDelimBase → NamedGram → AnyRef → Any
lazy val unparser: Unparser

Provides unparser.
Provides unparser.
Required to examine child unparsers, and optimize itself out by propagating NadaUnparser if there is no unparser.

Definition Classes
LiteralNilDelimitedEndOfData → StringDelimited → Gram
lazy val unparsingPadChar: MaybeChar

Definition Classes
PaddingInfoMixin
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( ... )
def warn(th: Diagnostic): Unit

Definition Classes
OOLAGHost
final def warnings: Seq[Diagnostic]

Definition Classes
OOLAGHost
macro def withLoggingLevel[S](newLevel: Type)(body: ⇒ S): Unit

Definition Classes
Logging
def ||(qq: ⇒ Gram): Gram

This || operator means one of the operands ONLY.
This || operator means one of the operands ONLY. I.e., statically they are supposed to be mutually exclusive, so only one (or none) of them should ever survive.

Definition Classes
Gram
def ~(qq: ⇒ Gram): Gram

Sequential composition operator in the grammar.
Sequential composition operator in the grammar.
Note: This should not evaluate the argument unless it has to.

Definition Classes
Gram

Related Doc: package primitives

case class LiteralNilDelimitedEndOfData(eb: ElementBase) extends StringDelimited with Product with Serializable

Instance Constructors

new LiteralNilDelimitedEndOfData(eb: ElementBase)

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def LV[T](sym: Symbol)(body: ⇒ T): OOLAGValue[T]

final def SDE(str: String, args: Any*): Nothing

final def SDW(warnID: WarnID, str: String, args: Any*): Unit

final def areLogging(lvl: Type): Boolean

final def asInstanceOf[T0]: T0

final def assuming(pred: Boolean): Unit

def checkDelimiterDistinctness(escapeSchemeKind: EscapeKind, optPadChar: Option[String], optEscChar: Option[String], optEscEscChar: Option[String], optEscBlkStart: Option[String], optEscBlkEnd: Option[String], terminatingMarkup: Seq[String], context: ThrowsSDE): Unit

final def checkErrors: Unit

def clone(): AnyRef

lazy val cname: String

final val context: SchemaComponent

final var currentOVList: Seq[OOLAGValueBase]

lazy val diagnosticDebugName: String

def diagnostics: Seq[Diagnostic]

def doLogging(lvl: Type, msg: String, args: Seq[Any]): Unit

final def eBase: ElementBase

lazy val eName: String

val eb: ElementBase

final def eq(arg0: AnyRef): Boolean

def error(th: Diagnostic): Unit

final def errors: Seq[Diagnostic]

lazy val es: Option[DFDLEscapeScheme]

lazy val escapeSchemeParseEvOpt: Maybe[EscapeSchemeParseEv]

lazy val escapeSchemeUnparseEvOpt: Maybe[EscapeSchemeUnparseEv]

lazy val fieldDFAParseEv: FieldDFAParseEv

def finalize(): Unit

val forWhat: ParserOrUnparser

final def getClass(): Class[_]

def getDiagnostics: Seq[Diagnostic]

def getLogWriter(): LogWriter

final def getLoggingLevel(): Type

final def hasNoParser: Parser

final def hasNoUnparser: Unparser

final def hasOOLAGRootSetup: Boolean

lazy val isDelimRequired: Boolean

def isEmpty: Boolean

def isError: Boolean

final def isInstanceOf[T0]: Boolean

lazy val justificationPad: Type

lazy val justificationTrim: Type

lazy val leftPaddingOpt: Option[TextPaddingParser]

final macro def log(lvl: Type, msg: String, args: Any*): Unit

lazy val logID: String

var logLevel: Maybe[Type]

var logWriter: Maybe[LogWriter]

final def maybeParser: Maybe[Parser]

final def maybeUnparser: Maybe[Unparser]

final val nArgs: Args

def name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final lazy val oolagContext: OOLAGHost

final def oolagContextViaArgs: Some[OOLAGHost]

def oolagError(th: Diagnostic): Unit

final def oolagParent: OOLAGHost

def oolagWarn(th: Diagnostic): Unit

lazy val parser: Parser

lazy val parsingPadChar: MaybeChar

lazy val path: String

final def requiredEvaluations(lv: OOLAGValueBase): Unit

final def requiredEvaluations(arg: ⇒ Any): Unit

def setLogWriter(lw: LogWriter): Unit

def setLoggingLevel(level: Type): Unit

final def setOOLAGContext(oolagContextArg: OOLAGHost): Unit

lazy val stringTruncationType: Type

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

val textDelimitedParser: TextDelimitedParserBase

def toString(): String

lazy val unparser: Unparser

lazy val unparsingPadChar: MaybeChar