xmlschema/io.github.pdvrieze.formats.xmlschema.resolved

Package-level declarations

Types

BuiltinListDerivation

class BuiltinListDerivation(itemType: ResolvedSimpleType) : ResolvedListDerivationBase

BuiltinSchemaXml

object BuiltinSchemaXml : ResolvedSchemaLike

BuiltinSchemaXmlInstance

object BuiltinSchemaXmlInstance : ResolvedSchemaLike

Built-in schema attribute declarations (3.2.7)

BuiltinSchemaXmlschema

object BuiltinSchemaXmlschema : ResolvedSchemaLike

ChameleonWrapper

class ChameleonWrapper : ResolvedSchemaLike

class DelegateMap<T : Any, V : NamedPart> : AbstractMap<String, V>

ElementNameCollector

class ElementNameCollector(collector: MutableList<QName>) : ResolvedTerm.ElementVisitor

sealed class FlattenedGroup : FlattenedParticle

FlattenedParticle

sealed class FlattenedParticle

interface IResolvedAll : ResolvedModelGroup

IResolvedAttributeUse

sealed interface IResolvedAttributeUse : ResolvedAnnotated

IResolvedChoice

interface IResolvedChoice : ResolvedModelGroup

IResolvedElementUse

sealed interface IResolvedElementUse : ResolvedAnnotated, ResolvedParticle<ResolvedElement>

IResolvedSequence

interface IResolvedSequence : ResolvedModelGroup

interface IScope

IsSiblingNameVisitor

class IsSiblingNameVisitor(name: QName) : ResolvedTerm.Visitor<Boolean>

interface ITypeTable

interface NamedPart

Parent interface for global (named) definitions

class OwnerWrapper : ResolvedSchemaLike

class ResolvedAll : ResolvedGroupParticleTermBase<IResolvedAll> , IResolvedAll

ResolvedAnnotated

interface ResolvedAnnotated

ResolvedAnnotation

class ResolvedAnnotation(rawPart: XSAnnotation)

class ResolvedAny : ResolvedWildcardBase<VQNameListBase.Elem> , ResolvedParticle<ResolvedAny> , ResolvedBasicTerm

ResolvedAnyAttribute

class ResolvedAnyAttribute : ResolvedWildcardBase<VQNameListBase.AttrElem>

ResolvedAttrContainer

interface ResolvedAttrContainer

ResolvedAttribute

sealed class ResolvedAttribute : ResolvedAnnotated, VSimpleTypeScope.Member

ResolvedAttributeDef

abstract class ResolvedAttributeDef(rawPart: XSAttribute) : ResolvedAttribute

ResolvedAttributeGroupRef

class ResolvedAttributeGroupRef(rawPart: XSAttributeGroupRef, schema: ResolvedSchemaLike) : ResolvedAnnotated

ResolvedAttributeRef

class ResolvedAttributeRef(parent: VAttributeScope.Member, rawPart: XSLocalAttribute, schema: ResolvedSchemaLike) : ResolvedAttribute, IResolvedAttributeUse

ResolvedBasicTerm

sealed interface ResolvedBasicTerm : ResolvedTerm

Either resolved element or resolved any

ResolvedBuiltinSimpleType

interface ResolvedBuiltinSimpleType : ResolvedGlobalSimpleType, ResolvedBuiltinType, ResolvedSimpleType.Model

ResolvedBuiltinType

interface ResolvedBuiltinType : ResolvedGlobalType

class ResolvedChoice : ResolvedGroupParticleTermBase<IResolvedChoice> , IResolvedChoice

ResolvedComplexType

sealed class ResolvedComplexType : ResolvedType, VAttributeScope.Member, ResolvedLocalElement.Parent, VElementScope.Member, VTypeScope.Member

ResolvedDirectKey

class ResolvedDirectKey(rawPart: XSKey, val schema: ResolvedSchemaLike, val owner: ResolvedElement) : ResolvedDirectReferenceable, ResolvedKey

ResolvedDirectKeyRef

class ResolvedDirectKeyRef(rawPart: XSKeyRef, val schema: ResolvedSchemaLike, val owner: ResolvedElement) : ResolvedNamedIdentityConstraint, ResolvedKeyRef

ResolvedDirectReferenceable

sealed class ResolvedDirectReferenceable : ResolvedNamedIdentityConstraint, ResolvedReferenceableConstraint

ResolvedDirectUnique

class ResolvedDirectUnique(rawPart: XSUnique, val schema: ResolvedSchemaLike, val owner: ResolvedElement) : ResolvedDirectReferenceable, ResolvedUnique

ResolvedElement

sealed class ResolvedElement : VTypeScope.Member, ResolvedBasicTerm, ResolvedAnnotated

ResolvedElementRef

class ResolvedElementRef(rawPart: XSLocalElement, schema: ResolvedSchemaLike, val mdlMinOccurs: VNonNegativeInteger = rawPart.minOccurs ?: VNonNegativeInteger.ONE, val mdlMaxOccurs: VAllNNI = rawPart.maxOccurs ?: VAllNNI.ONE) : IResolvedElementUse

ResolvedGlobalAttribute

class ResolvedGlobalAttribute : ResolvedAttributeDef, IScope.Global, NamedPart

ResolvedGlobalAttributeGroup

class ResolvedGlobalAttributeGroup : ResolvedAnnotated, NamedPart, VAttributeScope.Member

ResolvedGlobalComplexType

open class ResolvedGlobalComplexType(val mdlQName: QName, val schema: ResolvedSchemaLike, modelFactory: ResolvedGlobalComplexType.() -> ResolvedGlobalComplexType.Model, val mdlAbstract: Boolean = false, val location: String = "") : ResolvedComplexType, ResolvedGlobalType

ResolvedGlobalElement

class ResolvedGlobalElement : ResolvedElement, NamedPart

ResolvedGlobalGroup

class ResolvedGlobalGroup : ResolvedGroupBase, ResolvedAnnotated, VElementScope.Member, NamedPart

ResolvedGlobalSimpleType

interface ResolvedGlobalSimpleType : ResolvedGlobalType, ResolvedSimpleType

ResolvedGlobalSimpleTypeImpl

class ResolvedGlobalSimpleTypeImpl : ResolvedGlobalSimpleType

ResolvedGlobalType

sealed interface ResolvedGlobalType : ResolvedType, NamedPart

ResolvedGroupBase

sealed interface ResolvedGroupBase : ResolvedAnnotated

Base class for any resolved group related type

ResolvedGroupParticle

sealed interface ResolvedGroupParticle<out T : ResolvedTerm> : ResolvedComplexType.ResolvedDirectParticle<T> , ResolvedParticle<T>

Base interface for all group-like resolved types: all, seq, choice, group

ResolvedGroupParticleTermBase

sealed class ResolvedGroupParticleTermBase<T : ResolvedModelGroup> : ResolvedGroupParticle<T> , ResolvedTerm

ResolvedGroupRef

class ResolvedGroupRef(rawPart: XSGroupRef, schema: ResolvedSchemaLike, val mdlMinOccurs: VNonNegativeInteger = rawPart.minOccurs ?: VNonNegativeInteger.ONE, val mdlMaxOccurs: VAllNNI = rawPart.maxOccurs ?: VAllNNI.ONE) : ResolvedGroupBase, ResolvedGroupParticle<ResolvedModelGroup>

ResolvedIdentityConstraint

sealed interface ResolvedIdentityConstraint : ResolvedAnnotated

ResolvedIdentityConstraintBase

sealed class ResolvedIdentityConstraintBase : ResolvedAnnotated

ResolvedIndirectIdentityConstraint

sealed class ResolvedIndirectIdentityConstraint<T : ResolvedNamedIdentityConstraint> : ResolvedIdentityConstraintBase, ResolvedIdentityConstraint

ResolvedIndirectKey

class ResolvedIndirectKey(rawPart: XSKey, schema: ResolvedSchemaLike, owner: ResolvedElement) : ResolvedIndirectIdentityConstraint<ResolvedDirectKey> , ResolvedKey

ResolvedIndirectKeyRef

class ResolvedIndirectKeyRef(rawPart: XSKeyRef, schema: ResolvedSchemaLike, owner: ResolvedElement) : ResolvedIndirectIdentityConstraint<ResolvedDirectKeyRef> , ResolvedKeyRef

ResolvedIndirectUnique

class ResolvedIndirectUnique(rawPart: XSUnique, schema: ResolvedSchemaLike, owner: ResolvedElement) : ResolvedIndirectIdentityConstraint<ResolvedDirectUnique> , ResolvedUnique

interface ResolvedKey : ResolvedReferenceableConstraint

sealed interface ResolvedKeyRef : ResolvedIdentityConstraint

ResolvedListDerivation

class ResolvedListDerivation(rawPart: XSSimpleList, schema: ResolvedSchemaLike, context: ResolvedSimpleType) : ResolvedListDerivationBase

ResolvedListDerivationBase

abstract class ResolvedListDerivationBase : ResolvedSimpleType.Derivation

ResolvedLocalAttribute

class ResolvedLocalAttribute : ResolvedAttributeDef, IResolvedAttributeUse

ResolvedLocalComplexType

class ResolvedLocalComplexType : ResolvedComplexType, ResolvedLocalType, VSimpleTypeScope.Member

ResolvedLocalElement

class ResolvedLocalElement : ResolvedElement, IResolvedElementUse

ResolvedLocalSimpleType

class ResolvedLocalSimpleType(rawPart: XSLocalSimpleType, schema: ResolvedSchemaLike, context: VSimpleTypeScope.Member) : ResolvedLocalType, ResolvedSimpleType

ResolvedLocalType

sealed interface ResolvedLocalType : ResolvedType

ResolvedModelGroup

sealed interface ResolvedModelGroup : ResolvedTerm

ResolvedNamedIdentityConstraint

sealed class ResolvedNamedIdentityConstraint : ResolvedIdentityConstraintBase, ResolvedIdentityConstraint

ResolvedNotation

class ResolvedNotation(rawPart: XSNotation, val schema: ResolvedSchemaLike, val location: String) : ResolvedAnnotated, NamedPart

ResolvedOpenContent

class ResolvedOpenContent(val rawPart: XSOpenContent, schema: ResolvedSchemaLike, localInContext: Boolean)

ResolvedParticle

interface ResolvedParticle<out T : ResolvedTerm> : ResolvedAnnotated

ResolvedProhibitedAttribute

class ResolvedProhibitedAttribute(rawPart: XSLocalAttribute, schema: ResolvedSchemaLike) : IResolvedAttributeUse

ResolvedProhibitedElement

class ResolvedProhibitedElement(rawPart: XSLocalElement, schema: ResolvedSchemaLike) : IResolvedElementUse

ResolvedReferenceableConstraint

interface ResolvedReferenceableConstraint : ResolvedIdentityConstraint

class ResolvedSchema(val rawPart: XSSchema, resolver: ResolvedSchema.Resolver, defaultVersion: SchemaVersion = SchemaVersion.V1_1, builtin: Boolean = false) : ResolvedSchemaLike

ResolvedSchemaLike

abstract class ResolvedSchemaLike

ResolvedSequence

class ResolvedSequence : ResolvedGroupParticleTermBase<IResolvedSequence> , IResolvedSequence

ResolvedSimpleRestriction

class ResolvedSimpleRestriction(rawPart: XSSimpleRestriction, schema: ResolvedSchemaLike, context: ResolvedSimpleType) : ResolvedSimpleRestrictionBase

Restriction is used for simple types.

ResolvedSimpleRestrictionBase

abstract class ResolvedSimpleRestrictionBase(rawPart: XSSimpleRestriction?) : ResolvedSimpleType.Derivation

ResolvedSimpleType

sealed interface ResolvedSimpleType : ResolvedType, VSimpleTypeScope.Member

interface ResolvedTerm : ResolvedAnnotated

sealed interface ResolvedType : ResolvedAnnotated

ResolvedUnionDerivation

class ResolvedUnionDerivation(rawPart: XSSimpleUnion, schema: ResolvedSchemaLike, context: ResolvedSimpleType) : ResolvedSimpleType.Derivation

interface ResolvedUnique : ResolvedReferenceableConstraint

ResolvedWildcardBase

abstract class ResolvedWildcardBase<E : VQNameListBase.IElem> : ResolvedAnnotated

@Serializable(with = SchemaVersion.Companion::class)

enum SchemaVersion : Enum<SchemaVersion>

class SyntheticAll(val mdlMinOccurs: VNonNegativeInteger, val mdlMaxOccurs: VAllNNI, val mdlParticles: List<ResolvedParticle<ResolvedTerm>>) : ResolvedParticle<SyntheticAll> , IResolvedAll

SyntheticChoice

class SyntheticChoice(val mdlMinOccurs: VNonNegativeInteger, val mdlMaxOccurs: VAllNNI, val mdlParticles: List<ResolvedParticle<ResolvedTerm>>) : ResolvedParticle<SyntheticChoice> , IResolvedChoice

SyntheticSequence

class SyntheticSequence(val mdlMinOccurs: VNonNegativeInteger, val mdlMaxOccurs: VAllNNI, val mdlParticles: List<ResolvedParticle<ResolvedTerm>>) : ResolvedParticle<SyntheticSequence> , IResolvedSequence

SyntheticSimpleType

class SyntheticSimpleType(context: VSimpleTypeScope.Member, val mdlBaseTypeDefinition: ResolvedSimpleType, val mdlFacets: FacetList, val mdlFundamentalFacets: FundamentalFacets, val mdlVariety: ResolvedSimpleType.Variety, val mdlPrimitiveTypeDefinition: AnyPrimitiveDatatype?, val mdlItemTypeDefinition: ResolvedSimpleType?, val mdlMemberTypeDefinitions: List<ResolvedSimpleType>) : ResolvedSimpleType, ResolvedSimpleType.Model

class TypeTable(alternatives: List<T_AltType>, default: T_AltType?)

ValueConstraint

sealed class ValueConstraint

VAttributeScope

sealed class VAttributeScope : IScope

VComplexTypeScope

sealed class VComplexTypeScope : VTypeScope

interface VContentType

sealed class VElementScope : IScope

VSimpleTypeScope

sealed class VSimpleTypeScope : VTypeScope

sealed interface VTypeScope : IScope

Functions

fun ITypeTable?.isEquivalent(other: ITypeTable?): Boolean

fun XSAnnotation?.models(): ResolvedAnnotation?

TODO do this smarter, as 3.15.2.

resolvedOtherAttrs

fun XSI_OpenAttrs.resolvedOtherAttrs(): Map<QName, String>