Package com.evolveum.midpoint.prism.impl

Class DummyPrismObjectDefinition

    • Constructor Detail

      • DummyPrismObjectDefinition

        public DummyPrismObjectDefinition()

    • Method Detail

      • isOperational

        public boolean isOperational()
        Description copied from interface: ItemDefinition
        Marks operational item. Operational properties are auxiliary data (or meta-data) that are usually not modifiable by the end user. They are generated and maintained by the system. Operational items are also not usually displayed unless it is explicitly requested. The example of operational items are modification timestamps, create timestamps, user that made the last change, etc. They are also treated in a special way when comparing values. See ParameterizedEquivalenceStrategy.
        Specified by:
        isOperational in interface ItemDefinition<PrismContainer<Objectable>>

      • isDynamic

        public boolean isDynamic()
        Description copied from interface: ItemDefinition
        Returns true if definition was created during the runtime based on a dynamic information such as xsi:type attributes in XML. This means that the definition needs to be stored alongside the data to have a successful serialization "roundtrip". The definition is not part of any schema and therefore cannot be determined. It may even be different for every instance of the associated item (element name).
        Specified by:
        isDynamic in interface ItemDefinition<PrismContainer<Objectable>>

      • canRead

        public boolean canRead()
        Description copied from interface: PrismItemAccessDefinition
        Returns true if this item can be read (displayed). In case of containers this flag is, strictly speaking, not applicable. Container is an empty shell. What matters is access to individual sub-item. However, for containers this value has a "hint" meaning. It means that the container itself contains something that is readable. Which can be used as a hint by the presentation to display container label or block. This usually happens if the container contains at least one readable item. This does NOT mean that also all the container items can be displayed. The sub-item permissions are controlled by similar properties on the items. This property only applies to the container itself: the "shell" of the container.

        Note: It was considered to use a different meaning for this flag - a meaning that would allow canRead()=false containers to have readable items. However, this was found not to be very useful. Therefore the "something readable inside" meaning was confirmed instead.

        Specified by:
        canRead in interface PrismItemAccessDefinition

      • canModify

        public boolean canModify()
        Description copied from interface: PrismItemAccessDefinition
        Returns true if this item can be modified (updated). In case of containers this means that the container itself should be displayed in modification forms E.g. that the container label or block should be displayed. This usually happens if the container contains at least one modifiable item. This does NOT mean that also all the container items can be modified. The sub-item permissions are controlled by similar properties on the items. This property only applies to the container itself: the "shell" of the container.
        Specified by:
        canModify in interface PrismItemAccessDefinition

      • canAdd

        public boolean canAdd()
        Description copied from interface: PrismItemAccessDefinition
        Returns true if this item can be added: it can be part of an object that is created. In case of containers this means that the container itself should be displayed in creation forms E.g. that the container label or block should be displayed. This usually happens if the container contains at least one createable item. This does NOT mean that also all the container items can be created. The sub-item permissions are controlled by similar properties on the items. This property only applies to the container itself: the "shell" of the container.
        Specified by:
        canAdd in interface PrismItemAccessDefinition

      • getValueEnumerationRef

        public PrismReferenceValue getValueEnumerationRef()
        Description copied from interface: ItemDefinition
        Reference to an object that directly or indirectly represents possible values for this item. We do not define here what exactly the object has to be. It can be a lookup table, script that dynamically produces the values or anything similar. The object must produce the values of the correct type for this item otherwise an error occurs.
        Specified by:
        getValueEnumerationRef in interface ItemDefinition<PrismContainer<Objectable>>

      • isValidFor

        public boolean isValidFor​(@NotNull
                          @NotNull QName elementQName,
                          @NotNull
                          @NotNull Class<? extends ItemDefinition<?>> clazz,
                          boolean caseInsensitive)
        Description copied from interface: ItemDefinition
        Returns true if this definition is valid for given element name and definition class, in either case-sensitive (the default) or case-insensitive way. Used e.g. for "slow" path lookup where we iterate over all definitions in a complex type.
        Specified by:
        isValidFor in interface ItemDefinition<PrismContainer<Objectable>>

      • 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

      • 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

      • isIgnored

        public boolean isIgnored()
        Description copied from interface: Definition
        Item definition that has this flag set should be ignored by any processing. The ignored item is still part of the schema. Item instances may appear in the serialized data formats (e.g. XML) or data store and the parser should not raise an error if it encounters them. But any high-level processing code should ignore presence of this item. E.g. it should not be displayed to the user, should not be present in transformed data structures, etc. Note that the same item can be ignored at higher layer (e.g. presentation) but not ignored at lower layer (e.g. model). This works by presenting different item definitions for these layers (see LayerRefinedAttributeDefinition). Semantics of this flag for complex type definitions is to be defined yet.
        Specified by:
        isIgnored 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

      • getDisplayName

        public String getDisplayName()
        Description copied from interface: Definition
        Returns display name. Specifies the printable name of the object class or attribute. It must contain a printable string. It may also contain a key to catalog file. Returns null if no display name is set. Corresponds to "displayName" XSD annotation.
        Specified by:
        getDisplayName in interface Definition
        Returns:
        display name string or catalog key

      • 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

      • 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

      • freeze

        public void freeze()
        Specified by:
        freeze in interface Freezable