java.lang.Object
- com.evolveum.midpoint.prism.AbstractFreezable
- - com.evolveum.midpoint.common.refinery.LayerRefinedAttributeDefinitionImpl<T>

All Implemented Interfaces:

LayerRefinedAttributeDefinition<T>, RefinedAttributeDefinition<T>, Definition, Freezable, ItemDefinition<PrismProperty<T>>, PrismContextSensitive, PrismItemAccessDefinition, PrismPropertyDefinition<T>, Revivable, SmartVisitable<Definition>, Visitable<Definition>, ResourceAttributeDefinition<T>, DebugDumpable, Serializable, Cloneable
```
public final class LayerRefinedAttributeDefinitionImpl<T>
extends AbstractFreezable
implements LayerRefinedAttributeDefinition<T>
```
Author:

semancik

See Also:

Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface com.evolveum.midpoint.prism.PrismItemAccessDefinition
  PrismItemAccessDefinition.Mutable

Field Summary
- Fields inherited from interface com.evolveum.midpoint.util.DebugDumpable
  INDENT_STRING

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`accept(Visitor<Definition> visitor)`
`boolean`	`accept(Visitor<Definition> visitor, SmartVisitation<Definition> visitation)`
`void`	`adoptElementDefinitionFrom(ItemDefinition otherDef)`
`boolean`	`canAdd()`	Returns true if this item can be added: it can be part of an object that is created.
`boolean`	`canAdd(LayerType layer)`
`boolean`	`canBeDefinitionOf(PrismProperty<T> item)`
`boolean`	`canBeDefinitionOf(PrismValue pvalue)`
`boolean`	`canModify()`	Returns true if this item can be modified (updated).
`boolean`	`canModify(LayerType layer)`
`boolean`	`canRead()`	Returns true if this item can be read (displayed).
`boolean`	`canRead(LayerType layer)`
`@NotNull RefinedAttributeDefinition<T>`	`clone()`
`PropertyDelta<T>`	`createEmptyDelta(ItemPath path)`
`String`	`debugDump(int indent)`
`String`	`debugDump(int indent, LayerType layer)`
`void`	`debugDumpShortToString(StringBuilder sb)`	Used in debugDumping items.
`ItemDefinition<PrismProperty<T>>`	`deepClone(boolean ultraDeep, Consumer<ItemDefinition> postCloneAction)`
`RefinedAttributeDefinition<T>`	`deepClone(Map<QName,ComplexTypeDefinition> ctdMap, Map<QName,ComplexTypeDefinition> onThisPath, Consumer<ItemDefinition> postCloneAction)`
`T`	`defaultValue()`
`boolean`	`equals(Object obj)`
`<DT extends ItemDefinition> DT`	`findItemDefinition(@NotNull ItemPath path, @NotNull Class<DT> clazz)`
`Collection<? extends DisplayableValue<T>>`	`getAllowedValues()`
`<A> A`	`getAnnotation(QName qname)`	Returns generic definition annotation.
`ResourceAttributeDefinition<T>`	`getAttributeDefinition()`
`String`	`getDebugDumpClassName()`	Return a human readable name of this class suitable for logs.
`String`	`getDeprecatedSince()`
`String`	`getDescription()`
`List<ItemDiagramSpecification>`	`getDiagrams()`
`String`	`getDisplayName()`	Returns display name.
`Integer`	`getDisplayOrder()`	Specifies an order in which the item should be displayed relative to other items at the same level.
`String`	`getDocumentation()`
`String`	`getDocumentationPreview()`	Returns only a first sentence of documentation.
`AttributeFetchStrategyType`	`getFetchStrategy()`
`String`	`getFrameworkAttributeName()`
`String`	`getHelp()`	Returns help string.
`List<MappingType>`	`getInboundMappingTypes()`
`List<String>`	`getIntolerantValuePattern()`
`@NotNull ItemName`	`getItemName()`
`LayerType`	`getLayer()`
`PropertyLimitations`	`getLimitations()`
`PropertyLimitations`	`getLimitations(LayerType layer)`
`QName`	`getMatchingRuleQName()`
`int`	`getMaxOccurs()`
`int`	`getMaxOccurs(LayerType layer)`
`int`	`getMinOccurs()`
`int`	`getMinOccurs(LayerType layer)`
`Integer`	`getModificationPriority()`
`String`	`getNamespace()`
`String`	`getNativeAttributeName()`
`MappingType`	`getOutboundMappingType()`
`Boolean`	`getOverrideCanAdd()`
`Boolean`	`getOverrideCanModify()`
`Boolean`	`getOverrideCanRead()`
`String`	`getPlannedRemoval()`	Version of data model in which the item is likely to be removed.
`PrismContext`	`getPrismContext()`
`ItemProcessing`	`getProcessing()`
`ItemProcessing`	`getProcessing(LayerType layer)`
`Boolean`	`getReadReplaceMode()`
`Boolean`	`getReturnedByDefault()`
`List<SchemaMigration>`	`getSchemaMigrations()`
`AttributeStorageStrategyType`	`getStorageStrategy()`
`QName`	`getSubstitutionHead()`	Returns the name of an element this one can be substituted for (e.g.
`List<String>`	`getTolerantValuePattern()`
`Class`	`getTypeClass()`	Returns a compile-time class that is used to represent items.
`Class`	`getTypeClassIfKnown()`
`@NotNull QName`	`getTypeName()`	Returns a name of the type for this definition.
`PrismReferenceValue`	`getValueEnumerationRef()`
`QName`	`getValueType()`	Returns QName of the property value type.
`int`	`hashCode()`
`boolean`	`hasOutboundMapping()`
`@NotNull ResourceAttribute<T>`	`instantiate()`	Create an item instance.
`@NotNull ResourceAttribute<T>`	`instantiate(QName name)`	Create an item instance.
`boolean`	`isAbstract()`
`boolean`	`isDeprecated()`
`boolean`	`isDisplayNameAttribute()`
`boolean`	`isDynamic()`	Returns true if definition was created during the runtime based on a dynamic information such as xsi:type attributes in XML.
`boolean`	`isElaborate()`	Elaborate items are complicated data structure that may deviate from normal principles of the system.
`boolean`	`isEmphasized()`	True for definitions that are more important than others and that should be emphasized during presentation.
`boolean`	`isExclusiveStrong()`
`boolean`	`isExperimental()`	Experimental functionality is not stable and it may be changed in any future release without any warning.
`boolean`	`isHeterogeneousListItem()`	Can be used in heterogeneous lists as a list item.
`boolean`	`isIgnored()`	Item definition that has this flag set should be ignored by any processing.
`boolean`	`isIgnored(LayerType layer)`
`Boolean`	`isIndexed()`
`boolean`	`isIndexOnly()`	EXPERIMENTAL.
`boolean`	`isInherited()`	Whether an item is inherited from a supertype.
`boolean`	`isMandatory()`
`boolean`	`isMandatory(LayerType layer)`
`boolean`	`isMultiValue()`
`boolean`	`isMultiValue(LayerType layer)`
`boolean`	`isOperational()`
`boolean`	`isOptional()`
`boolean`	`isOptional(LayerType layer)`
`boolean`	`isPrimaryIdentifier(ObjectClassComplexTypeDefinition objectDefinition)`
`boolean`	`isPrimaryIdentifier(ResourceAttributeContainerDefinition objectDefinition)`
`boolean`	`isReturnedByDefault()`
`boolean`	`isRuntimeSchema()`	This means that this particular definition (of an item or of a type) is part of the runtime schema, e.g.
`boolean`	`isSecondaryIdentifier(ObjectClassComplexTypeDefinition objectDefinition)`
`Boolean`	`isSecondaryIdentifierOverride()`
`boolean`	`isSingleValue()`
`boolean`	`isSingleValue(LayerType layer)`
`boolean`	`isTolerant()`
`boolean`	`isValidFor(@NotNull QName elementQName, @NotNull Class<? extends ItemDefinition> clazz, boolean caseInsensitive)`
`boolean`	`isValidFor(QName elementQName, Class<? extends ItemDefinition> clazz)`
`boolean`	`isVolatilityTrigger()`
`void`	`revive(PrismContext prismContext)`
`<A> void`	`setAnnotation(QName qname, A value)`
`void`	`setOverrideCanAdd(Boolean overrideCanAdd)`
`void`	`setOverrideCanModify(Boolean overrideCanModify)`
`void`	`setOverrideCanRead(Boolean overrideCanRead)`
`Optional<ComplexTypeDefinition>`	`structuredType()`	Returns complex type definition of item, if underlying value is possible structured.
`MutableResourceAttributeDefinition<T>`	`toMutable()`
`String`	`toString()`

Methods inherited from class com.evolveum.midpoint.prism.AbstractFreezable
freeze, freeze, freezeAll, freezeNullableList, isImmutable, isMutable, performFreeze

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.evolveum.midpoint.util.DebugDumpable
debugDump, debugDumpLazily, debugDumpLazily

Methods inherited from interface com.evolveum.midpoint.prism.Definition
debugDump, getMutabilityFlag, getSchemaRegistry

Methods inherited from interface com.evolveum.midpoint.prism.Freezable
checkImmutable, checkMutable, freeze, isImmutable

Methods inherited from interface com.evolveum.midpoint.prism.PrismPropertyDefinition
isAnyType

- Method Detail
  - getLayer
```
public LayerType getLayer()
```
    Specified by:
    
    getLayer in interface LayerRefinedAttributeDefinition<T>
  - getOverrideCanRead
```
public Boolean getOverrideCanRead()
```
    Specified by:
    
    getOverrideCanRead in interface LayerRefinedAttributeDefinition<T>
  - setOverrideCanRead
```
public void setOverrideCanRead(Boolean overrideCanRead)
```
  - getOverrideCanAdd
```
public Boolean getOverrideCanAdd()
```
    Specified by:
    
    getOverrideCanAdd in interface LayerRefinedAttributeDefinition<T>
  - setOverrideCanAdd
```
public void setOverrideCanAdd(Boolean overrideCanAdd)
```
  - getOverrideCanModify
```
public Boolean getOverrideCanModify()
```
    Specified by:
    
    getOverrideCanModify in interface LayerRefinedAttributeDefinition<T>
  - setOverrideCanModify
```
public void setOverrideCanModify(Boolean overrideCanModify)
```
  - 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
  - getLimitations
```
public PropertyLimitations getLimitations()
```
    Specified by:
    
    getLimitations in interface LayerRefinedAttributeDefinition<T>
  - accept
```
public void accept(Visitor<Definition> visitor)
```
    Specified by:
    
    accept in interface Visitable<T>
  - accept
```
public boolean accept(Visitor<Definition> visitor,
                      SmartVisitation<Definition> visitation)
```
    Specified by:
    
    accept in interface SmartVisitable<T>
    
    Returns:
    
    false if we already was here
  - clone
```
@NotNull
public @NotNull RefinedAttributeDefinition<T> clone()
```
    Specified by:
    
    clone in interface Definition
    
    Specified by:
    
    clone in interface ItemDefinition<T>
    
    Specified by:
    
    clone in interface PrismPropertyDefinition<T>
    
    Specified by:
    
    clone in interface RefinedAttributeDefinition<T>
    
    Specified by:
    
    clone in interface ResourceAttributeDefinition<T>
    
    Overrides:
    
    clone in class Object
  - debugDump
```
public String debugDump(int indent,
                        LayerType layer)
```
    Specified by:
    
    debugDump in interface RefinedAttributeDefinition<T>
  - 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
  - isIgnored
```
public boolean isIgnored(LayerType layer)
```
    Specified by:
    
    isIgnored in interface RefinedAttributeDefinition<T>
  - getProcessing
```
public ItemProcessing getProcessing()
```
    Specified by:
    
    getProcessing in interface Definition
  - getProcessing
```
public ItemProcessing getProcessing(LayerType layer)
```
    Specified by:
    
    getProcessing in interface RefinedAttributeDefinition<T>
  - getSchemaMigrations
```
public List<SchemaMigration> getSchemaMigrations()
```
    Specified by:
    
    getSchemaMigrations in interface Definition
  - getDiagrams
```
public List<ItemDiagramSpecification> getDiagrams()
```
    Specified by:
    
    getDiagrams in interface Definition
  - 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
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - debugDump
```
public String debugDump(int indent)
```
    Specified by:
    
    debugDump in interface DebugDumpable
  - getDebugDumpClassName
```
public String getDebugDumpClassName()
```
    Return a human readable name of this class suitable for logs.
  - getFrameworkAttributeName
```
public String getFrameworkAttributeName()
```
    Specified by:
    
    getFrameworkAttributeName in interface ResourceAttributeDefinition<T>
  - isInherited
```
public boolean isInherited()
```
    Description copied from interface: ItemDefinition
    
    Whether an item is inherited from a supertype.
    
    Specified by:
    
    isInherited in interface ItemDefinition<T>
  - getModificationPriority
```
public Integer getModificationPriority()
```
    Specified by:
    
    getModificationPriority in interface RefinedAttributeDefinition<T>
  - getReadReplaceMode
```
public Boolean getReadReplaceMode()
```
    Specified by:
    
    getReadReplaceMode in interface RefinedAttributeDefinition<T>
  - findItemDefinition
```
public <DT extends ItemDefinition> DT findItemDefinition(@NotNull
                                                         @NotNull ItemPath path,
                                                         @NotNull
                                                         @NotNull Class<DT> clazz)
```
    Specified by:
    
    findItemDefinition in interface ItemDefinition<T>
  - isDisplayNameAttribute
```
public boolean isDisplayNameAttribute()
```
    Specified by:
    
    isDisplayNameAttribute in interface RefinedAttributeDefinition<T>
  - deepClone
```
public ItemDefinition<PrismProperty<T>> deepClone(boolean ultraDeep,
                                                  Consumer<ItemDefinition> postCloneAction)
```
    Specified by:
    
    deepClone in interface ItemDefinition<T>
  - revive
```
public void revive(PrismContext prismContext)
```
    Specified by:
    
    revive in interface ItemDefinition<T>
    
    Specified by:
    
    revive in interface Revivable
  - 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
  - getDocumentation
```
public String getDocumentation()
```
    Specified by:
    
    getDocumentation in interface Definition
  - getDocumentationPreview
```
public String getDocumentationPreview()
```
    Description copied from interface: Definition
    
    Returns only a first sentence of documentation.
    
    Specified by:
    
    getDocumentationPreview in interface Definition
  - 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
  - getPrismContext
```
public PrismContext getPrismContext()
```
    Specified by:
    
    getPrismContext in interface PrismContextSensitive
  - getTypeClassIfKnown
```
public Class getTypeClassIfKnown()
```
    Specified by:
    
    getTypeClassIfKnown in interface Definition
  - 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, sublcasses of Objectable and Containerable and so on.
    
    Specified by:
    
    getTypeClass in interface Definition
    
    Specified by:
    
    getTypeClass in interface PrismPropertyDefinition<T>
  - toMutable
```
public MutableResourceAttributeDefinition<T> toMutable()
```
    Specified by:
    
    toMutable in interface Definition
    
    Specified by:
    
    toMutable in interface ItemDefinition<T>
    
    Specified by:
    
    toMutable in interface PrismPropertyDefinition<T>
    
    Specified by:
    
    toMutable in interface ResourceAttributeDefinition<T>
  - getDescription
```
public String getDescription()
```
    Specified by:
    
    getDescription in interface RefinedAttributeDefinition<T>
  - getValueEnumerationRef
```
public PrismReferenceValue getValueEnumerationRef()
```
    Specified by:
    
    getValueEnumerationRef in interface ItemDefinition<T>
  - getAttributeDefinition
```
public ResourceAttributeDefinition<T> getAttributeDefinition()
```
    Specified by:
    
    getAttributeDefinition in interface RefinedAttributeDefinition<T>
  - isValidFor
```
public boolean isValidFor(QName elementQName,
                          Class<? extends ItemDefinition> clazz)
```
    Specified by:
    
    isValidFor in interface ItemDefinition<T>
  - getOutboundMappingType
```
public MappingType getOutboundMappingType()
```
    Specified by:
    
    getOutboundMappingType in interface RefinedAttributeDefinition<T>
  - hasOutboundMapping
```
public boolean hasOutboundMapping()
```
    Specified by:
    
    hasOutboundMapping in interface RefinedAttributeDefinition<T>
  - isValidFor
```
public boolean isValidFor(@NotNull
                          @NotNull QName elementQName,
                          @NotNull
                          @NotNull Class<? extends ItemDefinition> clazz,
                          boolean caseInsensitive)
```
    Specified by:
    
    isValidFor in interface ItemDefinition<T>
  - getInboundMappingTypes
```
public List<MappingType> getInboundMappingTypes()
```
    Specified by:
    
    getInboundMappingTypes in interface RefinedAttributeDefinition<T>
  - getMaxOccurs
```
public int getMaxOccurs(LayerType layer)
```
    Specified by:
    
    getMaxOccurs in interface RefinedAttributeDefinition<T>
  - getMinOccurs
```
public int getMinOccurs(LayerType layer)
```
    Specified by:
    
    getMinOccurs in interface RefinedAttributeDefinition<T>
  - adoptElementDefinitionFrom
```
public void adoptElementDefinitionFrom(ItemDefinition otherDef)
```
    Specified by:
    
    adoptElementDefinitionFrom in interface ItemDefinition<T>
  - isOptional
```
public boolean isOptional(LayerType layer)
```
    Specified by:
    
    isOptional in interface RefinedAttributeDefinition<T>
  - 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
  - isMandatory
```
public boolean isMandatory(LayerType layer)
```
    Specified by:
    
    isMandatory in interface RefinedAttributeDefinition<T>
  - isMultiValue
```
public boolean isMultiValue(LayerType layer)
```
    Specified by:
    
    isMultiValue in interface RefinedAttributeDefinition<T>
  - isSingleValue
```
public boolean isSingleValue(LayerType layer)
```
    Specified by:
    
    isSingleValue in interface RefinedAttributeDefinition<T>
  - isExclusiveStrong
```
public boolean isExclusiveStrong()
```
    Specified by:
    
    isExclusiveStrong in interface RefinedAttributeDefinition<T>
  - getLimitations
```
public PropertyLimitations getLimitations(LayerType layer)
```
    Specified by:
    
    getLimitations in interface RefinedAttributeDefinition<T>
  - getFetchStrategy
```
public AttributeFetchStrategyType getFetchStrategy()
```
    Specified by:
    
    getFetchStrategy in interface RefinedAttributeDefinition<T>
  - getStorageStrategy
```
public AttributeStorageStrategyType getStorageStrategy()
```
    Specified by:
    
    getStorageStrategy in interface RefinedAttributeDefinition<T>
  - getTolerantValuePattern
```
public List<String> getTolerantValuePattern()
```
    Specified by:
    
    getTolerantValuePattern in interface RefinedAttributeDefinition<T>
  - getIntolerantValuePattern
```
public List<String> getIntolerantValuePattern()
```
    Specified by:
    
    getIntolerantValuePattern in interface RefinedAttributeDefinition<T>
  - isVolatilityTrigger
```
public boolean isVolatilityTrigger()
```
    Specified by:
    
    isVolatilityTrigger in interface RefinedAttributeDefinition<T>
  - 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
  - instantiate
```
@NotNull
public @NotNull ResourceAttribute<T> instantiate()
```
    Description copied from interface: ItemDefinition
    
    Create an item instance. Definition name or default name will used as an element name for the instance. The instance will otherwise be empty.
    
    Specified by:
    
    instantiate in interface ItemDefinition<T>
    
    Specified by:
    
    instantiate in interface PrismPropertyDefinition<T>
    
    Specified by:
    
    instantiate in interface ResourceAttributeDefinition<T>
    
    Returns:
    
    created item instance
  - instantiate
```
@NotNull
public @NotNull ResourceAttribute<T> instantiate(QName name)
```
    Description copied from interface: ItemDefinition
    
    Create an item instance. Definition name will use provided name. for the instance. The instance will otherwise be empty.
    
    Specified by:
    
    instantiate in interface ItemDefinition<T>
    
    Specified by:
    
    instantiate in interface PrismPropertyDefinition<T>
    
    Specified by:
    
    instantiate in interface ResourceAttributeDefinition<T>
    
    Returns:
    
    created item instance
  - getReturnedByDefault
```
public Boolean getReturnedByDefault()
```
    Specified by:
    
    getReturnedByDefault in interface ResourceAttributeDefinition<T>
  - isReturnedByDefault
```
public boolean isReturnedByDefault()
```
    Specified by:
    
    isReturnedByDefault in interface ResourceAttributeDefinition<T>
  - isPrimaryIdentifier
```
public boolean isPrimaryIdentifier(ResourceAttributeContainerDefinition objectDefinition)
```
    Specified by:
    
    isPrimaryIdentifier in interface ResourceAttributeDefinition<T>
  - getItemName
```
@NotNull
public @NotNull ItemName getItemName()
```
    Specified by:
    
    getItemName in interface ItemDefinition<T>
  - getNamespace
```
public String getNamespace()
```
    Specified by:
    
    getNamespace in interface ItemDefinition<T>
  - getMinOccurs
```
public int getMinOccurs()
```
    Specified by:
    
    getMinOccurs in interface ItemDefinition<T>
  - getAllowedValues
```
public Collection<? extends DisplayableValue<T>> getAllowedValues()
```
    Specified by:
    
    getAllowedValues in interface PrismPropertyDefinition<T>
  - getMaxOccurs
```
public int getMaxOccurs()
```
    Specified by:
    
    getMaxOccurs in interface ItemDefinition<T>
  - isPrimaryIdentifier
```
public boolean isPrimaryIdentifier(ObjectClassComplexTypeDefinition objectDefinition)
```
    Specified by:
    
    isPrimaryIdentifier in interface ResourceAttributeDefinition<T>
  - defaultValue
```
public T defaultValue()
```
    Specified by:
    
    defaultValue in interface PrismPropertyDefinition<T>
  - isTolerant
```
public boolean isTolerant()
```
    Specified by:
    
    isTolerant in interface RefinedAttributeDefinition<T>
  - isSingleValue
```
public boolean isSingleValue()
```
    Specified by:
    
    isSingleValue in interface ItemDefinition<T>
  - getValueType
```
public QName getValueType()
```
    Description copied from interface: PrismPropertyDefinition
    
    Returns QName of the property value type.
    The returned type is either XSD simple type or complex type. It may not be defined in the same schema (especially if it is standard XSD simple type).
    
    Specified by:
    
    getValueType in interface PrismPropertyDefinition<T>
    
    Returns:
    
    QName of the property value type NOTE: This is very strange property. Isn't it the same as typeName(). It is even not used in midPoint. Marking as deprecated.
  - isSecondaryIdentifierOverride
```
public Boolean isSecondaryIdentifierOverride()
```
    Specified by:
    
    isSecondaryIdentifierOverride in interface RefinedAttributeDefinition<T>
  - isMultiValue
```
public boolean isMultiValue()
```
    Specified by:
    
    isMultiValue in interface ItemDefinition<T>
  - 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
  - isIndexed
```
public Boolean isIndexed()
```
    Specified by:
    
    isIndexed in interface PrismPropertyDefinition<T>
  - canAdd
```
public boolean canAdd(LayerType layer)
```
    Specified by:
    
    canAdd in interface RefinedAttributeDefinition<T>
  - isMandatory
```
public boolean isMandatory()
```
    Specified by:
    
    isMandatory in interface ItemDefinition<T>
  - 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
  - isSecondaryIdentifier
```
public boolean isSecondaryIdentifier(ObjectClassComplexTypeDefinition objectDefinition)
```
    Specified by:
    
    isSecondaryIdentifier in interface ResourceAttributeDefinition<T>
  - getMatchingRuleQName
```
public QName getMatchingRuleQName()
```
    Specified by:
    
    getMatchingRuleQName in interface PrismPropertyDefinition<T>
  - isAbstract
```
public boolean isAbstract()
```
    Specified by:
    
    isAbstract in interface Definition
  - isOptional
```
public boolean isOptional()
```
    Specified by:
    
    isOptional in interface ItemDefinition<T>
  - canRead
```
public boolean canRead(LayerType layer)
```
    Specified by:
    
    canRead in interface RefinedAttributeDefinition<T>
  - isDeprecated
```
public boolean isDeprecated()
```
    Specified by:
    
    isDeprecated in interface Definition
  - getDeprecatedSince
```
public String getDeprecatedSince()
```
    Specified by:
    
    getDeprecatedSince 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
  - isOperational
```
public boolean isOperational()
```
    Specified by:
    
    isOperational in interface ItemDefinition<T>
  - isIndexOnly
```
public boolean isIndexOnly()
```
    Description copied from interface: ItemDefinition
    
    EXPERIMENTAL. If true, this item is not stored in XML representation in repo. TODO better name
    
    Specified by:
    
    isIndexOnly in interface ItemDefinition<T>
  - createEmptyDelta
```
public PropertyDelta<T> createEmptyDelta(ItemPath path)
```
    Specified by:
    
    createEmptyDelta in interface ItemDefinition<T>
    
    Specified by:
    
    createEmptyDelta in interface PrismPropertyDefinition<T>
  - canModify
```
public boolean canModify(LayerType layer)
```
    Specified by:
    
    canModify in interface RefinedAttributeDefinition<T>
  - 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<T>
  - getNativeAttributeName
```
public String getNativeAttributeName()
```
    Specified by:
    
    getNativeAttributeName in interface ResourceAttributeDefinition<T>
  - deepClone
```
public RefinedAttributeDefinition<T> deepClone(Map<QName,ComplexTypeDefinition> ctdMap,
                                               Map<QName,ComplexTypeDefinition> onThisPath,
                                               Consumer<ItemDefinition> postCloneAction)
```
    Specified by:
    
    deepClone in interface ItemDefinition<T>
    
    Specified by:
    
    deepClone in interface RefinedAttributeDefinition<T>
  - getSubstitutionHead
```
public QName getSubstitutionHead()
```
    Description copied from interface: ItemDefinition
    
    Returns the name of an element this one can be substituted for (e.g. c:user -> c:object, s:pipeline -> s:expression, etc). EXPERIMENTAL
    
    Specified by:
    
    getSubstitutionHead in interface ItemDefinition<T>
  - isHeterogeneousListItem
```
public boolean isHeterogeneousListItem()
```
    Description copied from interface: ItemDefinition
    
    Can be used in heterogeneous lists as a list item. EXPERIMENTAL.
    
    Specified by:
    
    isHeterogeneousListItem in interface ItemDefinition<T>
  - debugDumpShortToString
```
public void debugDumpShortToString(StringBuilder sb)
```
    Description copied from interface: ItemDefinition
    
    Used in debugDumping items. Does not need to have name in it as item already has it. Does not need to have class as that is just too much info that is almost anytime pretty obvious anyway.
    
    Specified by:
    
    debugDumpShortToString in interface ItemDefinition<T>
  - canBeDefinitionOf
```
public boolean canBeDefinitionOf(PrismProperty<T> item)
```
    Specified by:
    
    canBeDefinitionOf in interface ItemDefinition<T>
  - canBeDefinitionOf
```
public boolean canBeDefinitionOf(PrismValue pvalue)
```
    Specified by:
    
    canBeDefinitionOf in interface ItemDefinition<T>
  - 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
  - setAnnotation
```
public <A> void setAnnotation(QName qname,
                              A value)
```
    Specified by:
    
    setAnnotation in interface Definition
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - structuredType
```
public Optional<ComplexTypeDefinition> structuredType()
```
    Description copied from interface: ItemDefinition
    
    Returns complex type definition of item, if underlying value is possible structured. NOTE: This seems weird, since properties and references are simple values, but actually object reference is serialized as structured value and some of properties are also.
    
    Specified by:
    
    structuredType in interface ItemDefinition<T>
    
    Returns:

Class LayerRefinedAttributeDefinitionImpl<T>

Nested Class Summary

Nested classes/interfaces inherited from interface com.evolveum.midpoint.prism.PrismItemAccessDefinition

Field Summary

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

Method Summary

Methods inherited from class com.evolveum.midpoint.prism.AbstractFreezable

Methods inherited from class java.lang.Object

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

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

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

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

Method Detail

getLayer

getOverrideCanRead

setOverrideCanRead

getOverrideCanAdd

setOverrideCanAdd

getOverrideCanModify

setOverrideCanModify

canAdd

getLimitations

accept

accept

clone

debugDump

canRead

isIgnored

getProcessing

getProcessing

getSchemaMigrations

getDiagrams

canModify

hashCode

equals

debugDump

getDebugDumpClassName

getFrameworkAttributeName

isInherited

getModificationPriority

getReadReplaceMode

findItemDefinition

isDisplayNameAttribute

deepClone

revive

getDisplayOrder

getHelp

getDocumentation

getDocumentationPreview

isRuntimeSchema

getPrismContext

getTypeClassIfKnown

getTypeClass

toMutable

getDescription

getValueEnumerationRef

getAttributeDefinition

isValidFor

getOutboundMappingType

hasOutboundMapping

isValidFor

getInboundMappingTypes

getMaxOccurs

getMinOccurs

adoptElementDefinitionFrom

isOptional

isEmphasized

isMandatory

isMultiValue

isSingleValue

isExclusiveStrong

getLimitations

getFetchStrategy

getStorageStrategy

getTolerantValuePattern

getIntolerantValuePattern

isVolatilityTrigger

getDisplayName

instantiate

instantiate