Package com.evolveum.midpoint.prism.schema

Interface SchemaRegistry

All Superinterfaces:

DebugDumpable, DefinitionsStore, GlobalDefinitionsStore, PrismContextSensitive

All Known Implementing Classes:

AxiomEnabledSchemaRegistry, SchemaRegistryImpl

public interface SchemaRegistry
extends PrismContextSensitive, DebugDumpable, GlobalDefinitionsStore

Maintains system-wide schemas.

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static class	SchemaRegistry.ComparisonResult
static interface	SchemaRegistry.InvalidationListener
static class	SchemaRegistry.IsList

Field Summary

Fields inherited from interface com.evolveum.midpoint.util.DebugDumpable

INDENT_STRING

Method Summary

Modifier and Type	Method	Description
<T extends Objectable> void	applyDefinition(ObjectDelta<T> objectDelta, Class<T> type, boolean force)
<C extends Containerable> void	applyDefinition(PrismContainer<C> container, Class<C> type)	This method will try to locate the appropriate object definition and apply it.
<C extends Containerable> void	applyDefinition(PrismContainer<C> prismObject, Class<C> type, boolean force)
<C extends Containerable,O extends Objectable> void	applyDefinition(PrismContainerValue<C> prismContainerValue, Class<O> type, ItemPath path, boolean force)
<C extends Containerable> void	applyDefinition(PrismContainerValue<C> prismContainerValue, QName typeName, ItemPath path, boolean force)
<ID extends ItemDefinition> SchemaRegistry.ComparisonResult	compareDefinitions(ID def1, ID def2)
ItemDefinition<?>	createAdHocDefinition(QName elementName, QName typeName, int minOccurs, int maxOccurs)
Class<?>	determineClassForItemDefinition(ItemDefinition<?> itemDefinition)
<T> Class<T>	determineClassForType(QName type)
default <T> Class<T>	determineClassForTypeRequired(QName type)
default <T> Class<T>	determineClassForTypeRequired(QName type, Class<T> expected)
<T> Class<T>	determineCompileTimeClass(QName typeName)
PrismObjectDefinition	determineDefinitionFromClass(Class type)
ComplexTypeDefinition	determineParentDefinition(@NotNull ComplexTypeDefinition child, @NotNull ItemPath rest)
PrismObjectDefinition	determineReferencedObjectDefinition(@NotNull QName targetTypeName, ItemPath rest)
QName	determineTypeForClass(Class<?> clazz)	Tries to determine type name for any class (primitive, complex one).
default @NotNull QName	determineTypeForClassRequired(Class<?> clazz)
ItemDefinition	findItemDefinitionByElementName(QName elementName, @Nullable List<String> ignoredNamespaces)
<T extends ItemDefinition> T	findItemDefinitionByFullPath(Class<? extends Objectable> objectClass, Class<T> defClass, QName... itemNames)
PrismSchema	findSchemaByCompileTimeClass(@NotNull Class<?> compileTimeClass)
PrismSchema	findSchemaByNamespace(String namespaceURI)
PrismSchema	findSchemaByPrefix(String prefix)
SchemaDescription	findSchemaDescriptionByNamespace(String namespaceURI)
SchemaDescription	findSchemaDescriptionByPrefix(String prefix)
<TD extends TypeDefinition> @NotNull Collection<TD>	findTypeDefinitionsByElementName(@NotNull QName name, @NotNull Class<TD> clazz)
<T> Class<T>	getCompileTimeClass(QName xsdType)
Class<? extends ObjectType>	getCompileTimeClassForObjectType(QName objectType)
Collection<Package>	getCompileTimePackages()
String	getDefaultNamespace()
Schema	getJavaxSchema()
Validator	getJavaxSchemaValidator()
DynamicNamespacePrefixMapper	getNamespacePrefixMapper()
PrismSchema	getPrismSchema(String namespace)
Collection<SchemaDescription>	getSchemaDescriptions()
Collection<PrismSchema>	getSchemas()
@NotNull PrismContainerDefinition<?>	getValueMetadataDefinition()
boolean	hasImplicitTypeDefinition(@NotNull QName itemName, @NotNull QName typeName)
void	initialize()
boolean	isAssignableFrom(@NotNull Class<?> superType, @NotNull QName subType)	BEWARE: works only with statically-defined types!
boolean	isAssignableFrom(@NotNull QName superType, @NotNull QName subType)	BEWARE: works only with statically-defined types!
boolean	isContainerable(QName typeName)
@NotNull SchemaRegistry.IsList	isList(@Nullable QName xsiType, @NotNull QName elementName)	Checks whether element with given (declared) xsi:type and name can be a heterogeneous list.
ItemDefinition	locateItemDefinition(@NotNull QName itemName, @Nullable ComplexTypeDefinition complexTypeDefinition, @Nullable Function<QName,ItemDefinition> dynamicDefinitionResolver)
QName	qualifyTypeName(QName typeName)
void	registerInvalidationListener(SchemaRegistry.InvalidationListener listener)
ItemDefinition	resolveGlobalItemDefinition(QName itemName, @Nullable ComplexTypeDefinition complexTypeDefinition)
QName	resolveUnqualifiedTypeName(QName type)
<ID extends ItemDefinition> ID	selectMoreSpecific(ID def1, ID def2)
QName	selectMoreSpecific(QName type1, QName type2)
PrismNamespaceContext	staticNamespaceContext()
QName	unifyTypes(QName type1, QName type2)	Returns most specific common supertype for these two.

Methods inherited from interface com.evolveum.midpoint.util.DebugDumpable

debugDump, debugDump, debugDumpLazily, debugDumpLazily

Methods inherited from interface com.evolveum.midpoint.prism.schema.GlobalDefinitionsStore

findComplexTypeDefinitionByCompileTimeClass, findComplexTypeDefinitionByType, findContainerDefinitionByCompileTimeClass, findContainerDefinitionByElementName, findContainerDefinitionByType, findItemDefinitionByCompileTimeClass, findItemDefinitionByElementName, findItemDefinitionByElementName, findItemDefinitionByType, findItemDefinitionByType, findItemDefinitionsByCompileTimeClass, findItemDefinitionsByElementName, findItemDefinitionsByElementName, findObjectDefinitionByCompileTimeClass, findObjectDefinitionByElementName, findObjectDefinitionByType, findPropertyDefinitionByElementName, findReferenceDefinitionByElementName, findSimpleTypeDefinitionByType, findTypeDefinitionByCompileTimeClass, findTypeDefinitionByType, findTypeDefinitionByType, findTypeDefinitionsByType, findTypeDefinitionsByType

Methods inherited from interface com.evolveum.midpoint.prism.PrismContextSensitive

getPrismContext

Method Detail

getNamespacePrefixMapper

DynamicNamespacePrefixMapper getNamespacePrefixMapper()

Returns:

System-wide "standard prefixes" registry.

staticNamespaceContext

PrismNamespaceContext staticNamespaceContext()

registerInvalidationListener

void registerInvalidationListener(SchemaRegistry.InvalidationListener listener)

getDefaultNamespace

String getDefaultNamespace()

initialize

void initialize()
         throws SAXException,
                IOException,
                SchemaException

Throws:

SAXException

IOException

SchemaException

getJavaxSchema

Schema getJavaxSchema()

getJavaxSchemaValidator

Validator getJavaxSchemaValidator()

getPrismSchema

PrismSchema getPrismSchema(String namespace)

getSchemas

Collection<PrismSchema> getSchemas()

getSchemaDescriptions

Collection<SchemaDescription> getSchemaDescriptions()

getCompileTimePackages

Collection<Package> getCompileTimePackages()

locateItemDefinition

ItemDefinition locateItemDefinition(@NotNull
                                    @NotNull QName itemName,
                                    @Nullable
                                    @Nullable ComplexTypeDefinition complexTypeDefinition,
                                    @Nullable
                                    @Nullable Function<QName,ItemDefinition> dynamicDefinitionResolver)

resolveUnqualifiedTypeName

QName resolveUnqualifiedTypeName(QName type)
                          throws SchemaException

Throws:

SchemaException

qualifyTypeName

QName qualifyTypeName(QName typeName)
               throws SchemaException

Throws:

SchemaException

determineParentDefinition

ComplexTypeDefinition determineParentDefinition(@NotNull
                                                @NotNull ComplexTypeDefinition child,
                                                @NotNull
                                                @NotNull ItemPath rest)

determineReferencedObjectDefinition

PrismObjectDefinition determineReferencedObjectDefinition(@NotNull
                                                          @NotNull QName targetTypeName,
                                                          ItemPath rest)

getCompileTimeClassForObjectType

Class<? extends ObjectType> getCompileTimeClassForObjectType(QName objectType)

findItemDefinitionByElementName

ItemDefinition findItemDefinitionByElementName(QName elementName,
                                               @Nullable
                                               @Nullable List<String> ignoredNamespaces)

determineCompileTimeClass

<T> Class<T> determineCompileTimeClass(QName typeName)

getCompileTimeClass

<T> Class<T> getCompileTimeClass(QName xsdType)

findSchemaByCompileTimeClass

PrismSchema findSchemaByCompileTimeClass(@NotNull
                                         @NotNull Class<?> compileTimeClass)

determineTypeForClass

QName determineTypeForClass(Class<?> clazz)

Tries to determine type name for any class (primitive, complex one). Does not use schemas (TODO explanation)

Parameters:

clazz -

Returns:

determineTypeForClassRequired

@NotNull
default @NotNull QName determineTypeForClassRequired(Class<?> clazz)

applyDefinition

<C extends Containerable> void applyDefinition(PrismContainer<C> container,
                                               Class<C> type)
                                        throws SchemaException

This method will try to locate the appropriate object definition and apply it.

Parameters:

container -

type -

Throws:

SchemaException

applyDefinition

<C extends Containerable> void applyDefinition(PrismContainer<C> prismObject,
                                               Class<C> type,
                                               boolean force)
                                        throws SchemaException

Throws:

SchemaException

applyDefinition

<T extends Objectable> void applyDefinition(ObjectDelta<T> objectDelta,
                                            Class<T> type,
                                            boolean force)
                                     throws SchemaException

Throws:

SchemaException

applyDefinition

<C extends Containerable,O extends Objectable> void applyDefinition(PrismContainerValue<C> prismContainerValue,
                                                                          Class<O> type,
                                                                          ItemPath path,
                                                                          boolean force)
                                                                   throws SchemaException

Throws:

SchemaException

applyDefinition

<C extends Containerable> void applyDefinition(PrismContainerValue<C> prismContainerValue,
                                               QName typeName,
                                               ItemPath path,
                                               boolean force)
                                        throws SchemaException

Throws:

SchemaException

findItemDefinitionByFullPath

<T extends ItemDefinition> T findItemDefinitionByFullPath(Class<? extends Objectable> objectClass,
                                                          Class<T> defClass,
                                                          QName... itemNames)
                                                   throws SchemaException

Throws:

SchemaException

findSchemaByNamespace

PrismSchema findSchemaByNamespace(String namespaceURI)

findSchemaDescriptionByNamespace

SchemaDescription findSchemaDescriptionByNamespace(String namespaceURI)

findSchemaByPrefix

PrismSchema findSchemaByPrefix(String prefix)

findSchemaDescriptionByPrefix

SchemaDescription findSchemaDescriptionByPrefix(String prefix)

determineDefinitionFromClass

PrismObjectDefinition determineDefinitionFromClass(Class type)

getValueMetadataDefinition

@NotNull
@NotNull PrismContainerDefinition<?> getValueMetadataDefinition()

hasImplicitTypeDefinition

boolean hasImplicitTypeDefinition(@NotNull
                                  @NotNull QName itemName,
                                  @NotNull
                                  @NotNull QName typeName)

resolveGlobalItemDefinition

ItemDefinition resolveGlobalItemDefinition(QName itemName,
                                           @Nullable
                                           @Nullable ComplexTypeDefinition complexTypeDefinition)

determineClassForType

<T> Class<T> determineClassForType(QName type)

determineClassForTypeRequired

default <T> Class<T> determineClassForTypeRequired(QName type,
                                                   Class<T> expected)

determineClassForTypeRequired

default <T> Class<T> determineClassForTypeRequired(QName type)

determineClassForItemDefinition

Class<?> determineClassForItemDefinition(ItemDefinition<?> itemDefinition)

selectMoreSpecific

<ID extends ItemDefinition> ID selectMoreSpecific(ID def1,
                                                  ID def2)
                                           throws SchemaException

Throws:

SchemaException

selectMoreSpecific

QName selectMoreSpecific(QName type1,
                         QName type2)
                  throws SchemaException

Throws:

SchemaException

isContainerable

boolean isContainerable(QName typeName)

Returns:

true if the typeName corresponds to statically-typed class that is Containerable. TODO The utility of this method is questionable. Reconsider its removal/update.

findTypeDefinitionsByElementName

@NotNull
<TD extends TypeDefinition> @NotNull Collection<TD> findTypeDefinitionsByElementName(@NotNull
                                                                                     @NotNull QName name,
                                                                                     @NotNull
                                                                                     @NotNull Class<TD> clazz)

isList

@NotNull
@NotNull SchemaRegistry.IsList isList(@Nullable
                                      @Nullable QName xsiType,
                                      @NotNull
                                      @NotNull QName elementName)

Checks whether element with given (declared) xsi:type and name can be a heterogeneous list.

Returns:

YES if it is a list, NO if it's not, MAYBE if it probably is a list but some further content-based checks are needed

compareDefinitions

<ID extends ItemDefinition> SchemaRegistry.ComparisonResult compareDefinitions(@NotNull
                                                                               ID def1,
                                                                               @NotNull
                                                                               ID def2)
                                                                        throws SchemaException

Returns:

null means we cannot decide (types are different, and no compile time class for def1 and/or def2)

Throws:

SchemaException

isAssignableFrom

boolean isAssignableFrom(@NotNull
                         @NotNull Class<?> superType,
                         @NotNull
                         @NotNull QName subType)

BEWARE: works only with statically-defined types!

isAssignableFrom

boolean isAssignableFrom(@NotNull
                         @NotNull QName superType,
                         @NotNull
                         @NotNull QName subType)

BEWARE: works only with statically-defined types!

unifyTypes

QName unifyTypes(QName type1,
                 QName type2)

Returns most specific common supertype for these two. If any of input params is null, it means it is ignored

Returns:

null if unification cannot be done (or if both input types are null)

createAdHocDefinition

ItemDefinition<?> createAdHocDefinition(QName elementName,
                                        QName typeName,
                                        int minOccurs,
                                        int maxOccurs)