java.lang.Object
- com.evolveum.midpoint.prism.AbstractFreezable
- - com.evolveum.midpoint.prism.impl.ItemImpl<V,D>

All Implemented Interfaces:

Freezable, Item<V,D>, Itemable, ParentVisitable, PathVisitable, PrismContextSensitive, Revivable, Visitable, DebugDumpable, Serializable

Direct Known Subclasses:

PrismContainerImpl, PrismPropertyImpl, PrismReferenceImpl
```
public abstract class ItemImpl<V extends PrismValue,D extends ItemDefinition>
extends AbstractFreezable
implements Item<V,D>
```
Item is a common abstraction of Property and PropertyContainer.
This is supposed to be a superclass for all items. Items are things that can appear in property containers, which generally means only a property and property container itself. Therefore this is in fact superclass for those two definitions.

Author:

Radovan Semancik

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field	Description
`protected D`	`definition`
`protected ItemName`	`elementName`
`protected boolean`	`immutable`
`protected boolean`	`incomplete`
`protected PrismContainerValue<?>`	`parent`
`protected PrismContext`	`prismContext`
`protected @NotNull List<V>`	`values`

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

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`accept(Visitor visitor)`
`void`	`accept(Visitor visitor, ItemPath path, boolean recursive)`
`void`	`acceptParentVisitor(@NotNull Visitor visitor)`	Accepts a visitor that visits each item/value on the way to the structure root.
`boolean`	`add(V newValue, @NotNull EquivalenceStrategy equivalenceStrategy)`	Adds a value, overwriting existing one(s).
`boolean`	`addAll(Collection<V> newValues, @NotNull EquivalenceStrategy strategy)`	Adds given values, with the same semantics as repeated add(..) calls.
`void`	`addForced(V newValue)`	Adds a given value with no checks, no definition application, and so on.
`void`	`addIgnoringEquivalents(V newValue)`	Adds a value, not looking for equivalent values.
`protected boolean`	`addInternal(V newValue, boolean checkEquivalents, EquivalenceStrategy equivalenceStrategy)`
`protected boolean`	`addInternalExecution(V newValue)`
`void`	`addRespectingMetadataAndCloning(V value, @NotNull EquivalenceStrategy strategy, EquivalenceStrategy metadataEquivalenceStrategy)`	Adds a value, respecting the metadata.
`protected void`	`appendDebugDumpSuffix(StringBuilder sb)`
`void`	`applyDefinition(D definition)`
`void`	`applyDefinition(D definition, boolean force)`
`void`	`assertDefinitions()`
`void`	`assertDefinitions(boolean tolarateRawValues, String sourceDescription)`
`void`	`assertDefinitions(String sourceDescription)`
`void`	`checkConsistence()`
`void`	`checkConsistence(boolean requireDefinitions, boolean prohibitRaw)`
`void`	`checkConsistence(boolean requireDefinitions, boolean prohibitRaw, ConsistencyCheckScope scope)`
`void`	`checkConsistence(boolean requireDefinitions, ConsistencyCheckScope scope)`
`void`	`checkConsistence(ConsistencyCheckScope scope)`
`void`	`checkConsistenceInternal(Itemable rootItem, boolean requireDefinitions, boolean prohibitRaw, ConsistencyCheckScope scope)`
`protected abstract void`	`checkDefinition(D def)`
`void`	`clear()`	Removes all values from the item.
`abstract Item<V,D>`	`clone()`	Literal clone.
`protected void`	`copyValues(CloneStrategy strategy, ItemImpl clone)`
`Item<V,D>`	`createImmutableClone()`
`String`	`debugDump(int indent)`
`ItemDelta<V,D>`	`diff(Item<V,D> other, @NotNull ParameterizedEquivalenceStrategy strategy)`	Computes a difference (delta) with the specified item using given equivalence strategy.
`boolean`	`equals(Object obj)`	Compares this item to the specified object under DEFAULT_FOR_EQUALS (DATA) strategy.
`boolean`	`equals(Object obj, @NotNull EquivalenceStrategy strategy)`	Compares this item to the specified object under given strategy.
`boolean`	`equals(Object obj, @NotNull ParameterizedEquivalenceStrategy parameterizedEquivalenceStrategy)`	Compares this item to the specified object under given strategy.
`protected ItemDelta<V,D>`	`fixupDelta(ItemDelta<V,D> delta, Item<V,D> other)`
`@NotNull Collection<PrismValue>`	`getAllValues(ItemPath path)`
`protected String`	`getDebugDumpClassName()`	Return a human readable name of this class suitable for logs.
`D`	`getDefinition()`	Returns applicable definition.
`ItemName`	`getElementName()`	Returns the name of the item.
`Long`	`getHighestId()`
`PrismContainerValue<?>`	`getParent()`	Returns the parent of this item (if exists).
`@NotNull ItemPath`	`getPath()`	Returns the path of this item (sequence of names from the "root" container or similar object to this item).
`protected Object`	`getPathComponent()`
`PrismContext`	`getPrismContext()`
`PrismContext`	`getPrismContextLocal()`
`@Nullable Object`	`getRealValue()`	Returns the "real value" (content) of this item: - value contained in PrismPropertyValue - Referencable in PrismReferenceValue - Containerable in PrismContainerValue - Objectable in PrismObjectValue Note that the real value can contain operational items.
`<X> X`	`getRealValue(Class<X> type)`	Type override, also for compatibility.
`<X> X[]`	`getRealValuesArray(Class<X> type)`	Type override, also for compatibility.
`@NotNull Map<String,Object>`	`getUserData()`	Returns the "user data", a map that allows attaching arbitrary named data to this item.
`<T> T`	`getUserData(String key)`	Returns the user data for the given key (name).
`V`	`getValue()`	Returns the value, if there is only one.
`@NotNull List<V>`	`getValues()`	Returns the values for this item.
`int`	`hashCode()`	Computes hash code to be used under DEFAULT_FOR_EQUALS (currently DATA) equivalence strategy.
`int`	`hashCode(@NotNull EquivalenceStrategy equivalenceStrategy)`	Computes hash code to be used under given equivalence strategy.
`int`	`hashCode(@NotNull ParameterizedEquivalenceStrategy equivalenceStrategy)`	Computes hash code to be used under given equivalence strategy.
`boolean`	`isIncomplete()`	Flag that indicates incomplete item.
`void`	`merge(Item<V,D> otherItem)`	Merge all the values of other item to this item.
`void`	`normalize()`
`void`	`performFreeze()`
`protected void`	`propagateDeepCloneDefinition(boolean ultraDeep, D clonedDefinition, Consumer<ItemDefinition> postCloneAction)`
`void`	`recomputeAllValues()`	Re-apply PolyString (and possible other) normalizations to the object.
`V`	`remove(int index)`
`boolean`	`remove(V value, @NotNull EquivalenceStrategy strategy)`	Removes values equivalent to given value from the item; under specified equivalence strategy OR when values represent the same value via "representsSameValue(.., lax=false)" method.
`boolean`	`removeAll(Collection<V> newValues, @NotNull EquivalenceStrategy strategy)`	Removes all given values from the item.
`void`	`removeRespectingMetadata(V value, @NotNull EquivalenceStrategy strategy, EquivalenceStrategy metadataEquivalenceStrategy)`	Removes values equivalent to given value from the item; under specified equivalence strategy OR when values represent the same value via "representsSameValue(.., lax=false)" method.
`void`	`replace(V newValue)`	Replaces all values of the item by given value.
`void`	`replaceAll(Collection<V> newValues, @NotNull EquivalenceStrategy strategy)`	Replaces all values of the item by given values.
`void`	`revive(PrismContext prismContext)`
`void`	`setDefinition(D definition)`	Sets applicable property definition.
`void`	`setElementName(QName elementName)`	Sets the name of the item.
`void`	`setIncomplete(boolean incomplete)`	Flags the item as incomplete.
`void`	`setParent(PrismContainerValue<?> parentValue)`	Sets the parent of this item.
`void`	`setPrismContext(PrismContext prismContext)`
`void`	`setUserData(String key, Object value)`	Sets the user data for the given key (name).
`String`	`toString()`

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

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.Freezable
checkImmutable, checkMutable, freeze, isImmutable

Methods inherited from interface com.evolveum.midpoint.prism.Item
add, addAll, cloneComplex, contains, contains, copy, createDelta, createDelta, diff, filterValues, filterYields, find, findPartial, findValue, findValue, getAnyValue, getAnyValue, getClonedValues, getDisplayName, getHelp, getRealValues, getRealValuesOrRawTypes, hasAnyValue, hasCompleteDefinition, hasNoValues, hasRaw, isEmpty, isOperational, isRaw, isSingleValue, isSingleValueByDefinition, remove, removeIf, size, valuesStream

- Field Detail
  - elementName
```
protected ItemName elementName
```
  - parent
```
protected PrismContainerValue<?> parent
```
  - definition
```
protected D extends ItemDefinition definition
```
  - values
```
@NotNull
protected final @NotNull List<V extends PrismValue> values
```
  - immutable
```
protected boolean immutable
```
  - incomplete
```
protected boolean incomplete
```
  - prismContext
```
protected transient PrismContext prismContext
```
- Method Detail
  - getDefinition
```
public D getDefinition()
```
    Description copied from interface: Item
    
    Returns applicable definition.
    May return null if no definition is applicable or the definition is not known.
    
    Specified by:
    
    getDefinition in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Specified by:
    
    getDefinition in interface Itemable
    
    Returns:
    
    applicable definition
  - getElementName
```
public ItemName getElementName()
```
    Description copied from interface: Item
    
    Returns the name of the item.
    The name is a QName. It uniquely defines an item.
    The name may be null, but such an item will not work.
    The name is the QName of XML element in the XML representation.
    
    Specified by:
    
    getElementName in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Specified by:
    
    getElementName in interface Itemable
    
    Returns:
    
    item name TODO consider making element name obligatory
  - setElementName
```
public void setElementName(QName elementName)
```
    Description copied from interface: Item
    
    Sets the name of the item.
    The name is a QName. It uniquely defines an item.
    The name may be null, but such an item will not work.
    The name is the QName of XML element in the XML representation.
    
    Specified by:
    
    setElementName in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Parameters:
    
    elementName - the name to set TODO consider removing this method
  - setDefinition
```
public void setDefinition(D definition)
```
    Sets applicable property definition.
    
    Specified by:
    
    setDefinition in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Parameters:
    
    definition - the definition to set
  - isIncomplete
```
public boolean isIncomplete()
```
    Description copied from interface: Item
    
    Flag that indicates incomplete item. If set to true then the values in this item are not complete. If this flag is true then it can be assumed that the object that this item represents has at least one value. This is a method how to indicate that the item really has some values, but are not here. This may be used for variety of purposes. It may indicate that the account has a password, but the password value is not revealed. This may indicate that a user has a photo, but the photo was not requested and therefore is not returned. This may be used to indicate that only part of the attribute values were returned from the search. And so on.
    
    Specified by:
    
    isIncomplete in interface Item<V extends PrismValue,D extends ItemDefinition>
  - setIncomplete
```
public void setIncomplete(boolean incomplete)
```
    Description copied from interface: Item
    
    Flags the item as incomplete.
    
    Specified by:
    
    setIncomplete in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Parameters:
    
    incomplete - The new value
    
    See Also:
    
    FIXME: Should be package-visible to implementation
  - getPrismContext
```
public PrismContext getPrismContext()
```
    Specified by:
    
    getPrismContext in interface PrismContextSensitive
  - getPrismContextLocal
```
public PrismContext getPrismContextLocal()
```
    Specified by:
    
    getPrismContextLocal in interface Item<V extends PrismValue,D extends ItemDefinition>
  - setPrismContext
```
public void setPrismContext(PrismContext prismContext)
```
    Specified by:
    
    setPrismContext in interface Item<V extends PrismValue,D extends ItemDefinition>
  - getParent
```
public PrismContainerValue<?> getParent()
```
    Description copied from interface: Item
    
    Returns the parent of this item (if exists). Currently this has to be a PrismContainerValue.
    
    Specified by:
    
    getParent in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Returns:
    
    The parent if exists
  - setParent
```
public void setParent(PrismContainerValue<?> parentValue)
```
    Description copied from interface: Item
    
    Sets the parent of this item.
    
    Specified by:
    
    setParent in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Parameters:
    
    parentValue - The new parent
  - getPathComponent
```
protected Object getPathComponent()
```
  - getRealValue
```
@Nullable
public @Nullable Object getRealValue()
```
    Description copied from interface: Item
    
    Returns the "real value" (content) of this item: - value contained in PrismPropertyValue - Referencable in PrismReferenceValue - Containerable in PrismContainerValue - Objectable in PrismObjectValue Note that the real value can contain operational items. It can also contain container IDs (although they are not considered to be part of the real value). It does not contain information about item element name nor other metadata like origin, definition, etc. (Although e.g. Containerable can be converted back into PrismContainerValue that can be used to retrieve this information.)
    
    Specified by:
    
    getRealValue in interface Item<V extends PrismValue,D extends ItemDefinition>
  - getRealValue
```
public <X> X getRealValue(Class<X> type)
```
    Type override, also for compatibility.
    
    Specified by:
    
    getRealValue in interface Item<V extends PrismValue,D extends ItemDefinition>
  - getRealValuesArray
```
public <X> X[] getRealValuesArray(Class<X> type)
```
    Type override, also for compatibility.
    
    Specified by:
    
    getRealValuesArray in interface Item<V extends PrismValue,D extends ItemDefinition>
  - getPath
```
@NotNull
public @NotNull ItemPath getPath()
```
    Description copied from interface: Item
    
    Returns the path of this item (sequence of names from the "root" container or similar object to this item). Note that if the containing object is a delta (usually a container delta), then the path
    
    Specified by:
    
    getPath in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Specified by:
    
    getPath in interface Itemable
    
    Returns:
    
    the path
  - acceptParentVisitor
```
public void acceptParentVisitor(@NotNull
                                @NotNull Visitor visitor)
```
    Description copied from interface: Item
    
    Accepts a visitor that visits each item/value on the way to the structure root.
    
    Specified by:
    
    acceptParentVisitor in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Specified by:
    
    acceptParentVisitor in interface ParentVisitable
  - getUserData
```
@NotNull
public @NotNull Map<String,Object> getUserData()
```
    Description copied from interface: Item
    
    Returns the "user data", a map that allows attaching arbitrary named data to this item.
    
    Specified by:
    
    getUserData in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Returns:
    
    the user data map
  - getUserData
```
public <T> T getUserData(String key)
```
    Description copied from interface: Item
    
    Returns the user data for the given key (name).
    
    Specified by:
    
    getUserData in interface Item<V extends PrismValue,D extends ItemDefinition>
  - setUserData
```
public void setUserData(String key,
                        Object value)
```
    Description copied from interface: Item
    
    Sets the user data for the given key (name).
    
    Specified by:
    
    setUserData in interface Item<V extends PrismValue,D extends ItemDefinition>
  - getValues
```
@NotNull
public @NotNull List<V> getValues()
```
    Description copied from interface: Item
    
    Returns the values for this item. Although the ordering of this values is not important, and each value should be present at most once, we currently return them as a list instead of a set. TODO reconsider this
    
    Specified by:
    
    getValues in interface Item<V extends PrismValue,D extends ItemDefinition>
  - getValue
```
public V getValue()
```
    Description copied from interface: Item
    
    Returns the value, if there is only one. Throws exception if there are more values. If there is no value, this method either: - returns null (for properties) - throws an exception (for items that can hold multiple values) - creates an empty value (for containers and references). TODO think again whether getOrCreateValue would not be better
    
    Specified by:
    
    getValue in interface Item<V extends PrismValue,D extends ItemDefinition>
  - addAll
```
public boolean addAll(Collection<V> newValues,
                      @NotNull
                      @NotNull EquivalenceStrategy strategy)
               throws SchemaException
```
    Description copied from interface: Item
    
    Adds given values, with the same semantics as repeated add(..) calls. For equality testing uses given strategy.
    
    Specified by:
    
    addAll in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Returns:
    
    true if this item changed as a result of the call (i.e. if at least one value was really added)
    
    Throws:
    
    SchemaException
  - add
```
public boolean add(@NotNull
                   V newValue,
                   @NotNull
                   @NotNull EquivalenceStrategy equivalenceStrategy)
            throws SchemaException
```
    Description copied from interface: Item
    
    Adds a value, overwriting existing one(s). Uses specified equivalence strategy.
    
    Specified by:
    
    add in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Returns:
    
    true if this item changed as a result of the call. This is either during real value addition or during overwriting existing value with a different one. The "difference" is taken using the DEFAULT_FOR_EQUALS (DATA) equivalence strategy.
    
    Throws:
    
    SchemaException
  - addIgnoringEquivalents
```
public void addIgnoringEquivalents(@NotNull
                                   V newValue)
                            throws SchemaException
```
    Description copied from interface: Item
    
    Adds a value, not looking for equivalent values. (This means that the new value is always added, if possible.) Note that we check the cardinality of the item according to its definition, i.e. we do not allow single-valued item to contain more than one value.
    
    Specified by:
    
    addIgnoringEquivalents in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - addInternal
```
@Contract("_, true, null -> fail; _, false, !null -> fail")
protected boolean addInternal(@NotNull
                              V newValue,
                              boolean checkEquivalents,
                              EquivalenceStrategy equivalenceStrategy)
                       throws SchemaException
```
    Throws:
    
    SchemaException
  - addInternalExecution
```
protected boolean addInternalExecution(@NotNull
                                       V newValue)
```
  - addForced
```
@Experimental
public void addForced(@NotNull
                      V newValue)
```
    Adds a given value with no checks, no definition application, and so on. For internal use only.
  - addRespectingMetadataAndCloning
```
public void addRespectingMetadataAndCloning(V value,
                                            @NotNull
                                            @NotNull EquivalenceStrategy strategy,
                                            EquivalenceStrategy metadataEquivalenceStrategy)
                                     throws SchemaException
```
    Description copied from interface: Item
    
    Adds a value, respecting the metadata. I.e. if equivalent value exists, the metadata are merged. (Replacing metadata of colliding provenance, adding all the others.) If a value is to be added as a whole, it is cloned.
    
    Specified by:
    
    addRespectingMetadataAndCloning in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - removeRespectingMetadata
```
public void removeRespectingMetadata(V value,
                                     @NotNull
                                     @NotNull EquivalenceStrategy strategy,
                                     EquivalenceStrategy metadataEquivalenceStrategy)
```
    Description copied from interface: Item
    
    Removes values equivalent to given value from the item; under specified equivalence strategy OR when values represent the same value via "representsSameValue(.., lax=false)" method. Respects metadata, i.e. if value to be removed has metadata specified, this method removes only particular metadata. Only if this means that all metadata are gone, then the value is deleted.
    
    Specified by:
    
    removeRespectingMetadata in interface Item<V extends PrismValue,D extends ItemDefinition>
  - removeAll
```
public boolean removeAll(Collection<V> newValues,
                         @NotNull
                         @NotNull EquivalenceStrategy strategy)
```
    Description copied from interface: Item
    
    Removes all given values from the item. It is basically a shortcut for repeated Item.remove(PrismValue, EquivalenceStrategy) call.
    
    Specified by:
    
    removeAll in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Returns:
    
    true if this item changed as a result of the call (i.e. if at least one value was really removed)
  - remove
```
public boolean remove(V value,
                      @NotNull
                      @NotNull EquivalenceStrategy strategy)
```
    Description copied from interface: Item
    
    Removes values equivalent to given value from the item; under specified equivalence strategy OR when values represent the same value via "representsSameValue(.., lax=false)" method.
    
    Specified by:
    
    remove in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Returns:
    
    true if this item changed as a result of the call (i.e. if at least one value was really removed)
  - remove
```
public V remove(int index)
```
  - replaceAll
```
public void replaceAll(Collection<V> newValues,
                       @NotNull
                       @NotNull EquivalenceStrategy strategy)
                throws SchemaException
```
    Description copied from interface: Item
    
    Replaces all values of the item by given values.
    
    Specified by:
    
    replaceAll in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - replace
```
public void replace(V newValue)
             throws SchemaException
```
    Description copied from interface: Item
    
    Replaces all values of the item by given value.
    
    Specified by:
    
    replace in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - clear
```
public void clear()
```
    Description copied from interface: Item
    
    Removes all values from the item.
    
    Specified by:
    
    clear in interface Item<V extends PrismValue,D extends ItemDefinition>
  - normalize
```
public void normalize()
```
    Specified by:
    
    normalize in interface Item<V extends PrismValue,D extends ItemDefinition>
  - merge
```
public void merge(Item<V,D> otherItem)
           throws SchemaException
```
    Merge all the values of other item to this item.
    
    Specified by:
    
    merge in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - diff
```
public ItemDelta<V,D> diff(Item<V,D> other,
                                 @NotNull
                                 @NotNull ParameterizedEquivalenceStrategy strategy)
```
    Description copied from interface: Item
    
    Computes a difference (delta) with the specified item using given equivalence strategy. Note this method cannot accept general EquivalenceStrategy here; it needs the parameterized strategy. Compares item values only -- does NOT dive into lower levels.
    
    Specified by:
    
    diff in interface Item<V extends PrismValue,D extends ItemDefinition>
  - fixupDelta
```
protected ItemDelta<V,D> fixupDelta(ItemDelta<V,D> delta,
                                          Item<V,D> other)
```
  - accept
```
public void accept(Visitor visitor)
```
    Specified by:
    
    accept in interface Visitable<V extends PrismValue>
  - accept
```
public void accept(Visitor visitor,
                   ItemPath path,
                   boolean recursive)
```
    Specified by:
    
    accept in interface PathVisitable
  - recomputeAllValues
```
public void recomputeAllValues()
```
    Re-apply PolyString (and possible other) normalizations to the object.
    
    Specified by:
    
    recomputeAllValues in interface Item<V extends PrismValue,D extends ItemDefinition>
  - applyDefinition
```
public void applyDefinition(D definition)
                     throws SchemaException
```
    Specified by:
    
    applyDefinition in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - applyDefinition
```
public void applyDefinition(D definition,
                            boolean force)
                     throws SchemaException
```
    Specified by:
    
    applyDefinition in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - revive
```
public void revive(PrismContext prismContext)
            throws SchemaException
```
    Specified by:
    
    revive in interface Revivable
    
    Throws:
    
    SchemaException
  - copyValues
```
protected void copyValues(CloneStrategy strategy,
                          ItemImpl clone)
```
  - propagateDeepCloneDefinition
```
protected void propagateDeepCloneDefinition(boolean ultraDeep,
                                            D clonedDefinition,
                                            Consumer<ItemDefinition> postCloneAction)
```
  - checkConsistence
```
public void checkConsistence(boolean requireDefinitions,
                             ConsistencyCheckScope scope)
```
    Specified by:
    
    checkConsistence in interface Item<V extends PrismValue,D extends ItemDefinition>
  - checkConsistence
```
public void checkConsistence(boolean requireDefinitions,
                             boolean prohibitRaw)
```
    Specified by:
    
    checkConsistence in interface Item<V extends PrismValue,D extends ItemDefinition>
  - checkConsistence
```
public void checkConsistence(boolean requireDefinitions,
                             boolean prohibitRaw,
                             ConsistencyCheckScope scope)
```
    Specified by:
    
    checkConsistence in interface Item<V extends PrismValue,D extends ItemDefinition>
  - checkConsistence
```
public void checkConsistence()
```
    Specified by:
    
    checkConsistence in interface Item<V extends PrismValue,D extends ItemDefinition>
  - checkConsistence
```
public void checkConsistence(ConsistencyCheckScope scope)
```
    Specified by:
    
    checkConsistence in interface Item<V extends PrismValue,D extends ItemDefinition>
  - checkConsistenceInternal
```
public void checkConsistenceInternal(Itemable rootItem,
                                     boolean requireDefinitions,
                                     boolean prohibitRaw,
                                     ConsistencyCheckScope scope)
```
    Specified by:
    
    checkConsistenceInternal in interface Item<V extends PrismValue,D extends ItemDefinition>
  - checkDefinition
```
protected abstract void checkDefinition(D def)
```
  - assertDefinitions
```
public void assertDefinitions()
                       throws SchemaException
```
    Specified by:
    
    assertDefinitions in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - assertDefinitions
```
public void assertDefinitions(String sourceDescription)
                       throws SchemaException
```
    Specified by:
    
    assertDefinitions in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - assertDefinitions
```
public void assertDefinitions(boolean tolarateRawValues,
                              String sourceDescription)
                       throws SchemaException
```
    Specified by:
    
    assertDefinitions in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - hashCode
```
public int hashCode(@NotNull
                    @NotNull EquivalenceStrategy equivalenceStrategy)
```
    Description copied from interface: Item
    
    Computes hash code to be used under given equivalence strategy.
    
    Specified by:
    
    hashCode in interface Item<V extends PrismValue,D extends ItemDefinition>
  - hashCode
```
public int hashCode(@NotNull
                    @NotNull ParameterizedEquivalenceStrategy equivalenceStrategy)
```
    Description copied from interface: Item
    
    Computes hash code to be used under given equivalence strategy.
    
    Specified by:
    
    hashCode in interface Item<V extends PrismValue,D extends ItemDefinition>
  - hashCode
```
public int hashCode()
```
    Description copied from interface: Item
    
    Computes hash code to be used under DEFAULT_FOR_EQUALS (currently DATA) equivalence strategy.
    
    Specified by:
    
    hashCode in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj,
                      @NotNull
                      @NotNull EquivalenceStrategy strategy)
```
    Description copied from interface: Item
    
    Compares this item to the specified object under given strategy.
    
    Specified by:
    
    equals in interface Item<V extends PrismValue,D extends ItemDefinition>
  - equals
```
public boolean equals(Object obj,
                      @NotNull
                      @NotNull ParameterizedEquivalenceStrategy parameterizedEquivalenceStrategy)
```
    Description copied from interface: Item
    
    Compares this item to the specified object under given strategy.
    
    Specified by:
    
    equals in interface Item<V extends PrismValue,D extends ItemDefinition>
  - equals
```
public boolean equals(Object obj)
```
    Description copied from interface: Item
    
    Compares this item to the specified object under DEFAULT_FOR_EQUALS (DATA) strategy.
    
    Specified by:
    
    equals in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - debugDump
```
public String debugDump(int indent)
```
    Specified by:
    
    debugDump in interface DebugDumpable
  - getDebugDumpClassName
```
protected String getDebugDumpClassName()
```
    Return a human readable name of this class suitable for logs.
  - appendDebugDumpSuffix
```
protected void appendDebugDumpSuffix(StringBuilder sb)
```
  - performFreeze
```
public void performFreeze()
```
    Overrides:
    
    performFreeze in class AbstractFreezable
  - getAllValues
```
@NotNull
public @NotNull Collection<PrismValue> getAllValues(ItemPath path)
```
    Specified by:
    
    getAllValues in interface Item<V extends PrismValue,D extends ItemDefinition>
  - clone
```
public abstract Item<V,D> clone()
```
    Description copied from interface: Item
    
    Literal clone.
    
    Specified by:
    
    clone in interface Item<V extends PrismValue,D extends ItemDefinition>
    
    Overrides:
    
    clone in class Object
  - createImmutableClone
```
public Item<V,D> createImmutableClone()
```
    Specified by:
    
    createImmutableClone in interface Item<V extends PrismValue,D extends ItemDefinition>
  - getHighestId
```
public Long getHighestId()
```
    Specified by:
    
    getHighestId in interface Item<V extends PrismValue,D extends ItemDefinition>

Class ItemImpl<V extends PrismValue,​D extends ItemDefinition>

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.Freezable

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

Field Detail

elementName

parent

definition

values

immutable

incomplete

prismContext

Method Detail

getDefinition

getElementName

setElementName

setDefinition

isIncomplete

setIncomplete

getPrismContext

getPrismContextLocal

setPrismContext

getParent

setParent

getPathComponent

getRealValue

getRealValue

getRealValuesArray

getPath

acceptParentVisitor

getUserData

getUserData

setUserData

getValues

getValue

addAll

add

addIgnoringEquivalents

addInternal

addInternalExecution

addForced

addRespectingMetadataAndCloning

removeRespectingMetadata

removeAll

remove

remove

replaceAll

replace

clear

normalize

merge

diff

fixupDelta

accept

accept

recomputeAllValues

applyDefinition

applyDefinition

revive

copyValues

propagateDeepCloneDefinition

checkConsistence

checkConsistence

checkConsistence

checkConsistence

checkConsistence

checkConsistenceInternal

checkDefinition

assertDefinitions

assertDefinitions

assertDefinitions

hashCode

hashCode

hashCode

equals

Class ItemImpl<V extends PrismValue,D extends ItemDefinition>