Package com.evolveum.midpoint.schema.processor

Class AbstractResourceObjectDefinitionImpl

    • Method Detail

      • getPrimaryIdentifiers

        @NotNull
public @NotNull Collection<ResourceAttributeDefinition<?>> getPrimaryIdentifiers()
        Description copied from interface: IdentifiersDefinitionStore
        Returns the definition of primary identifier attributes of a resource object. May return empty set if there are no identifier attributes. Must not return null. The exception should be never thrown unless there is some bug in the code. The validation of model consistency should be done at the time of schema parsing.
        Specified by:
        getPrimaryIdentifiers in interface IdentifiersDefinitionStore
        Returns:
        definition of identifier attributes

      • getSecondaryIdentifiers

        @NotNull
public @NotNull Collection<ResourceAttributeDefinition<?>> getSecondaryIdentifiers()
        Description copied from interface: IdentifiersDefinitionStore
        Returns the definition of secondary identifier attributes of a resource object. May return empty set if there are no secondary identifier attributes. Must not return null. The exception should be never thrown unless there is some bug in the code. The validation of model consistency should be done at the time of schema parsing.
        Specified by:
        getSecondaryIdentifiers in interface IdentifiersDefinitionStore
        Returns:
        definition of secondary identifier attributes

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • revive

        public void revive​(PrismContext prismContext)
        Description copied from interface: Revivable
        TODO: Is revive necessary if prism context is static? TODO document (if it's found to be necessary)
        Specified by:
        revive in interface Revivable

      • getCompileTimeClass

        @Nullable
public @Nullable Class<?> getCompileTimeClass()
        Description copied from interface: TypeDefinition
        Returns compile-time class, if this type has any. For example, UserType.class, ObjectType.class, ExtensionType.class.
        Specified by:
        getCompileTimeClass in interface TypeDefinition

      • getSuperType

        @Nullable
public @Nullable QName getSuperType()
        Description copied from interface: TypeDefinition
        Name of super type of this complex type definition. E.g. c:ObjectType is a super type for c:FocusType which is a super type for c:UserType. Or (more complex example) ri:ShadowAttributesType is a super type of ri:AccountObjectClass. (TODO is this really true?)
        Specified by:
        getSuperType in interface TypeDefinition

      • addDebugDumpHeaderExtension

        protected void addDebugDumpHeaderExtension​(StringBuilder sb)

      • getExtensionForType

        @Nullable
public @Nullable QName getExtensionForType()
        Description copied from interface: ComplexTypeDefinition
        If not null, indicates that this type defines the structure of `extension` element of a given type. E.g. `getExtensionForType()` == `c:UserType` means that this complex type defines structure of `extension` elements of `UserType` objects.
        Specified by:
        getExtensionForType in interface ComplexTypeDefinition

      • isContainerMarker

        public boolean isContainerMarker()
        Description copied from interface: ComplexTypeDefinition
        Flag indicating whether this type was marked as "container" in the original schema. Does not provide any information to schema processing logic, just conveys the marker from original schema so we can serialize and deserialize the schema without loss of information.
        Specified by:
        isContainerMarker in interface ComplexTypeDefinition

      • isObjectMarker

        public boolean isObjectMarker()
        Description copied from interface: ComplexTypeDefinition
        Flag indicating whether this type was marked as "object" in the original schema. Does not provide any information to schema processing logic, just conveys the marker from original schema so we can serialized and deserialize the schema without loss of information.
        Specified by:
        isObjectMarker in interface ComplexTypeDefinition

      • getDefaultNamespace

        @Nullable
public @Nullable String getDefaultNamespace()
        Description copied from interface: ComplexTypeDefinition
        When resolving unqualified names for items contained in this CTD, what should be the default namespace to look into at first. Currently does NOT apply recursively (to inner CTDs). Set by parsing `defaultNamespace` XSD annotation.
        Specified by:
        getDefaultNamespace in interface ComplexTypeDefinition

      • getIgnoredNamespaces

        @NotNull
public @NotNull List<String> getIgnoredNamespaces()
        Description copied from interface: ComplexTypeDefinition
        When resolving unqualified names for items contained in this CTD, what namespace(s) should be ignored. Names in this list are interpreted as a namespace prefixes. Currently does NOT apply recursively (to inner CTDs). Set by parsing `ignoredNamespace` XSD annotations.
        Specified by:
        getIgnoredNamespaces in interface ComplexTypeDefinition

      • getTypeName

        @NotNull
public @NotNull QName getTypeName()
        Description copied from interface: Definition
        Returns a name of the type for this definition. The type can be part of the compile-time schema or it can be defined at run time. Examples of the former case are types like c:UserType, xsd:string, or even flexible ones like c:ExtensionType or c:ShadowAttributesType. Examples of the latter case are types used in - custom extensions, like ext:LocationsType (where ext = e.g. http://example.com/extension), - resource schema, like ri:inetOrgPerson (ri = http://.../resource/instance-3), - connector schema, like TODO In XML representation that corresponds to the name of the XSD type. Although beware, the run-time types do not have statically defined structure. And the resource and connector-related types may even represent different kinds of objects within different contexts (e.g. two distinct resources both with ri:AccountObjectClass types). Also note that for complex type definitions, the type name serves as a unique identifier. On the other hand, for item definitions, it is just one of its attributes; primary key is item name in that case. The type name should be fully qualified. (TODO reconsider this)
        Specified by:
        getTypeName in interface Definition
        Returns:
        the type name

      • isRuntimeSchema

        public boolean isRuntimeSchema()
        Description copied from interface: Definition
        This means that this particular definition (of an item or of a type) is part of the runtime schema, e.g. extension schema, resource schema or connector schema or something like that. I.e. it is not defined statically.
        Specified by:
        isRuntimeSchema in interface Definition

      • isAbstract

        public boolean isAbstract()
        Description copied from interface: Definition
        For types: is the type abstract so that it should not be instantiated directly? For items: TODO
        Specified by:
        isAbstract in interface Definition

      • isExperimental

        public boolean isExperimental()
        Description copied from interface: Definition
        Experimental functionality is not stable and it may be changed in any future release without any warning. Use at your own risk.
        Specified by:
        isExperimental in interface Definition

      • getPlannedRemoval

        public String getPlannedRemoval()
        Description copied from interface: Definition
        Version of data model in which the item is likely to be removed. This annotation is used for deprecated item to indicate imminent incompatibility in future versions of data model.
        Specified by:
        getPlannedRemoval in interface Definition

      • isElaborate

        public boolean isElaborate()
        Description copied from interface: Definition
        Elaborate items are complicated data structure that may deviate from normal principles of the system. For example elaborate items may not be supported in user interface and may only be manageable by raw edits or a special-purpose tools. Elaborate items may be not fully supported by authorizations, schema tools and so on.
        Specified by:
        isElaborate in interface Definition

      • isEmphasized

        public boolean isEmphasized()
        Description copied from interface: Definition
        True for definitions that are more important than others and that should be emphasized during presentation. E.g. the emphasized definitions will always be displayed in the user interfaces (even if they are empty), they will always be included in the dumps, etc.
        Specified by:
        isEmphasized in interface Definition

      • getDisplayOrder

        public Integer getDisplayOrder()
        Description copied from interface: Definition
        Specifies an order in which the item should be displayed relative to other items at the same level. The items will be displayed by sorting them by the values of displayOrder annotation (ascending). Items that do not have any displayOrder annotation will be displayed last. The ordering of values with the same displayOrder is undefined and it may be arbitrary.
        Specified by:
        getDisplayOrder in interface Definition

      • getHelp

        public String getHelp()
        Description copied from interface: Definition
        Returns help string. Specifies the help text or a key to catalog file for a help text. The help text may be displayed in any suitable way by the GUI. It should explain the meaning of an attribute or object class. Returns null if no help string is set. Corresponds to "help" XSD annotation.
        Specified by:
        getHelp in interface Definition
        Returns:
        help string or catalog key

      • getTypeClass

        public Class<?> getTypeClass()
        Description copied from interface: Definition
        Returns a compile-time class that is used to represent items. E.g. returns String, Integer, subclasses of Objectable and Containerable and so on.
        Specified by:
        getTypeClass in interface Definition

      • getAnnotation

        public <A> A getAnnotation​(QName qname)
        Description copied from interface: Definition
        Returns generic definition annotation. Annotations are a method to extend schema definitions. This may be annotation stored in the schema definition file (e.g. XSD) or it may be a dynamic annotation determined at run-time. Annotation value should be a prism-supported object. E.g. a prims "bean" (JAXB annotated class), prism item, prism value or something like that. EXPERIMENTAL. Hic sunt leones. This may change at any moment. Note: annotations are only partially supported now (3.8). They are somehow transient. E.g. they are not serialized to XSD schema definitions (yet).
        Specified by:
        getAnnotation in interface Definition

      • getAnnotations

        @Nullable
public @Nullable Map<QName,​Object> getAnnotations()
        Description copied from interface: Definition
        Returns all annotations, as unmodifiable map. Nullable by design, to avoid creating lots of empty maps.
        Specified by:
        getAnnotations in interface Definition

      • trimTo

        public void trimTo​(@NotNull
                   @NotNull Collection<ItemPath> paths)
        Description copied from interface: ComplexTypeDefinition
        Trims the definition (and any definitions it refers to) to contain only items related to given paths. USE WITH CARE. Be sure no shared definitions would be affected by this operation!
        Specified by:
        trimTo in interface ComplexTypeDefinition