AnnotatedSchemaComponent

abstract def annotationFactory(node: Node): Option[DFDLAnnotation]

Anything annotated must be able to construct the appropriate DFDLAnnotation object from the xml.

abstract def emptyFormatFactory: DFDLFormatAnnotation

Here we establish an invariant which is that every annotatable schema component has, definitely, has an annotation object.

abstract def enclosingComponentDef: Option[SchemaComponent]

Define this for schema components that have back-references to ref objects.

abstract def enclosingComponentDefs: Seq[EnclosingComponentDef]

abstract def isMyFormatAnnotation(a: DFDLAnnotation): Boolean

abstract def optLexicalParent: Option[SchemaComponent]

abstract def optReferredToComponent: Option[AnnotatedSchemaComponent]

abstract def xml: Node

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

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

def NoAnnotationContext: Option[SchemaFileLocation]

def SDE(id: String, args: Any*): Nothing

final def SDE(th: Throwable): Nothing

def SDEButContinue(id: String, args: Any*): Unit

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

def ThrowSDE: PartialFunction[Throwable, Nothing]

final lazy val annotationObjs: Seq[DFDLAnnotation]

The DFDL annotations on the component, as objects that are subtypes of DFDLAnnotation.

final def areLogging(lvl: Type): Boolean

final def asInstanceOf[T0]: T0

final def assuming(pred: Boolean): Unit

final def checkErrors: Unit

final def checkNonOverlap(providers: Seq[ChainPropProvider]): Unit

check for overlap.

final def ci: DPathCompileInfo

Abbreviation.

def clone(): AnyRef

final lazy val columnAttribute: Option[String]

lazy val columnDescription: String

lazy val columnNumber: Option[String]

final var currentOVList: Seq[OOLAGValueBase]

def dafAttributes(n: Node): MetaData

final lazy val defaultFormatChain: ChainPropProvider

final lazy val defaultPropertySources: Seq[ChainPropProvider]

lazy val dfdlAppInfos: NodeSeq

def dfdlAttributes(n: Node): MetaData

def dfdlxAttributes(n: Node): MetaData

lazy val diagnosticDebugName: String

def diagnostics: Seq[Diagnostic]

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

lazy val dpathCompileInfo: DPathCompileInfo

val emptyPropMap: PropMap

final lazy val enclosingComponent: Option[SchemaComponent]

The enclosing component, and follows back-references from types to their elements, from globalElementDef to elementRefs, from simpleType defs to derived simpletype defs, from global group defs to group refs

final lazy val enclosingComponents: Seq[EnclosingComponentDef]

final lazy val enclosingElement: Option[ElementBase]

All schema components except the root have an enclosing element.

final lazy val enclosingElements: Seq[ElementBase]

Elements that enclose this.

final lazy val enclosingTerm: Option[Term]

final lazy val enclosingTerms: Seq[Term]

The terms that can enclose this.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(th: Diagnostic): Unit

final def errors: Seq[Diagnostic]

final lazy val fileAttribute: Option[String]

lazy val fileDescription: String

def finalize(): Unit

final lazy val formatAnnotation: DFDLFormatAnnotation

final lazy val formatAnnotationExpectedName: String

def getAttributeOption(ns: NS, name: String): Option[String]

def getAttributeOption(name: String): Option[String]

def getAttributeRequired(name: String): String

final def getClass(): Class[_]

def getDiagnostics: Seq[Diagnostic]

def getLogWriter(): LogWriter

final def getLoggingLevel(): Type

final def hasOOLAGRootSetup: Boolean

def hashCode(): Int

def isError: Boolean

def isHidden: Boolean

Whether the component is hidden.

final def isInstanceOf[T0]: Boolean

lazy val lineAttribute: Option[String]

Annotations can contain expressions, so we need to be able to compile them.

lazy val lineDescription: String

lazy val lineNumber: Option[String]

lazy val locationDescription: String

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

lazy val logID: String

var logLevel: Maybe[Type]

var logWriter: Maybe[LogWriter]

def nArgs: Args

final lazy val namespaces: NamespaceBinding

Namespace scope for resolving QNames.

final def ne(arg0: AnyRef): Boolean

final def newDFDLAnnotationXML(label: String): Elem

Used as factory for the XML Node with the right namespace and prefix etc.

final lazy val nonDefaultFormatChain: ChainPropProvider

lazy val nonDefaultPropertySources: Seq[ChainPropProvider]

final def nonTermRuntimeData: NonTermRuntimeData

final def notYetImplemented(msg: String, args: Any*): Nothing

final def notify(): Unit

final def notifyAll(): Unit

final lazy val oolagContext: OOLAGHost

def oolagContextViaArgs: Option[SchemaComponent]

def oolagError(th: Diagnostic): Unit

final def oolagParent: OOLAGHost

def oolagWarn(th: Diagnostic): Unit

final lazy val optOolagContext: Option[OOLAGHost]

final val orElseURL: String

lazy val path: String

path is used in diagnostic messages and code debug messages; hence, it is very important that it be very dependable.

def qNameForProperty(local: String, ns: NS): GlobalQName

final def refersToForPropertyCombining: Option[AnnotatedSchemaComponent]

For property combining only.

def removePrefix(prefixedValue: String): String

final def requiredEvaluations(lv: OOLAGValueBase): Unit

final def requiredEvaluations(arg: ⇒ Any): Unit

def resolveQName(qnString: String): RefQName

lazy val runtimeData: RuntimeData

All non-terms get runtimeData from this definition.

lazy val schema: Schema

lazy val schemaComponent: LookupLocation

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

def schemaDefinitionErrorButContinue(str: String, args: Any*): Unit

def schemaDefinitionErrorDueToPropertyValue(propertyName: String, propertyValue: String, propertyLocation: LookupLocation, otherPropertyLocation: LookupLocation, str: String, args: Any*): Nothing

final macro def schemaDefinitionUnless(testThatWillThrowIfFalse: Boolean, str: String, args: Any*): Unit

macro def schemaDefinitionWarningUnless(warnID: WarnID, testThatWillWarnIfFalse: Boolean, str: String, args: Any*): Unit

macro def schemaDefinitionWarningWhen(warnID: WarnID, testThatWillWarnIfTrue: Boolean, str: String, args: Any*): Unit

final macro def schemaDefinitionWhen(testThatWillThrowIfTrue: Boolean, str: String, args: Any*): Unit

def schemaDocument: SchemaDocument

lazy val schemaFile: Option[DFDLSchemaFile]

lazy val schemaFileLocation: SchemaFileLocation

lazy val schemaSet: SchemaSet

def setLogWriter(lw: LogWriter): Unit

def setLoggingLevel(level: Type): Unit

final def setOOLAGContext(oolagContextArg: OOLAGHost): Unit

lazy val shortSchemaComponentDesignator: String

final lazy val slashPath: String

Elements only e.g., /foo/ex:bar

def subset(testThatWillThrowIfFalse: Boolean, msg: String, args: Any*): Unit

def subsetError(msg: String, args: Any*): Nothing

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

def targetNamespace: NS

This is the root, or basic target namespace.

final lazy val targetNamespacePrefix: String

def toString(): String

final def toss(th: Throwable): Nothing

lazy val tunable: DaffodilTunables

final lazy val unqualifiedPathStepPolicy: UnqualifiedPathStepPolicy

def uriString: String

Used in diagnostic messages; hence, valueOrElse to avoid problems when this can't get a value due to an error.

lazy val uriStringFromAttribute: Option[String]

def variableMap: VariableMap

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warn(th: Diagnostic): Unit

final def warnings: Seq[Diagnostic]

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

lazy val xmlSchemaDocument: XMLSchemaDocument