IIBase

abstract def mapPair: (NS, DaffodilSchemaSource)

abstract def resolvedLocation: DaffodilSchemaSource

Holds the location of the schema, whether that is from the XML Catalog (import), or classpath (import or include).

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 def areLogging(lvl: Type): Boolean

final def asInstanceOf[T0]: T0

final def assuming(pred: Boolean): Unit

final def checkErrors: Unit

def clone(): AnyRef

final lazy val columnAttribute: Option[String]

lazy val columnDescription: String

lazy val columnNumber: Option[String]

val context: SchemaComponent

final var currentOVList: Seq[OOLAGValueBase]

def dafAttributes(n: Node): MetaData

def dfdlAttributes(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

def enclosingComponentDef: Option[SchemaComponent]

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

final lazy val enclosingElement: Option[ElementBase]

All schema components except the root have an enclosing element.

final lazy val enclosingTerm: Option[Term]

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

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

final def iiSchemaFile: DFDLSchemaFile

Unconditionally, get the schema file object.

final def iiSchemaFileMaybe: Option[DFDLSchemaFile]

Get the schema file if it isn't one we have seen before.

def isError: Boolean

def isHidden: Boolean

Whether the component is hidden.

final def isInstanceOf[T0]: Boolean

final def isValidURI(uri: String): 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]

final def mapTuple: ((NS, DaffodilSchemaSource), IIBase)

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 def nonTermRuntimeData: NonTermRuntimeData

final def notSeenThisBefore: Boolean

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

final def notify(): Unit

final def notifyAll(): Unit

final lazy val oolagContext: OOLAGHost

final def oolagContextViaArgs: Some[SchemaComponent]

def oolagError(th: Diagnostic): Unit

final def oolagParent: OOLAGHost

def oolagWarn(th: Diagnostic): Unit

final val orElseURL: String

final def parent: XMLSchemaDocument

The lexically enclosing schema component

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

def removePrefix(prefixedValue: String): String

final def requiredEvaluations(lv: OOLAGValueBase): Unit

final def requiredEvaluations(arg: ⇒ Any): Unit

def resolveQName(qnString: String): RefQName

final lazy val resolvedSchemaLocation: Option[DaffodilSchemaSource]

Both include and import have schemaLocation.

final lazy val rootElementDecl: Option[GlobalElementDecl]

final lazy val rootElementRef: Option[AbstractElementRef]

lazy val runtimeData: RuntimeData

ALl non-terms get runtimeData from this definition.

final lazy val scPath: Seq[SchemaComponent]

Includes instances.

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

final lazy val schemaLocationProperty: Option[String]

lazy val schemaSet: SchemaSet

final def seenAfter: IIMap

val seenBefore: IIMap

final def seenBeforeThisFile: IIMap

(ns, file) that we've seen before.

def setLogWriter(lw: LogWriter): Unit

def setLoggingLevel(level: Type): Unit

final def setOOLAGContext(oolagContextArg: OOLAGHost): Unit

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

def tunable: DaffodilTunables

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]

final lazy val whereSearched: String

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

final val xml: Node

lazy val xmlSchemaDocument: XMLSchemaDocument