java.lang.Object
- com.evolveum.midpoint.prism.impl.delta.ItemDeltaImpl<V,D>

All Implemented Interfaces:

ItemDelta<V,D>, Itemable, PathVisitable, Visitable, DebugDumpable, Foreachable<V>, Serializable

Direct Known Subclasses:

ContainerDeltaImpl, PropertyDeltaImpl, ReferenceDeltaImpl
```
public abstract class ItemDeltaImpl<V extends PrismValue,D extends ItemDefinition>
extends Object
implements ItemDelta<V,D>
```
Author:

Radovan Semancik

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field	Description
`protected D`	`definition`
`protected ItemName`	`elementName`	Name of the property
`protected Collection<V>`	`estimatedOldValues`
`protected ItemPath`	`fullPath`
`protected ItemPath`	`parentPath`	Parent path of the property (path to the property container)
`protected Collection<V>`	`valuesToAdd`
`protected Collection<V>`	`valuesToDelete`
`protected Collection<V>`	`valuesToReplace`

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

Constructor Summary

Constructors
Modifier	Constructor	Description
`protected`	`ItemDeltaImpl(ItemPath path, D itemDefinition, PrismContext prismContext)`
`protected`	`ItemDeltaImpl(ItemPath itemPath, QName elementName, D itemDefinition, PrismContext prismContext)`
`protected`	`ItemDeltaImpl(D itemDefinition, PrismContext prismContext)`
`protected`	`ItemDeltaImpl(QName elementName, D itemDefinition, PrismContext prismContext)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`accept(Visitor visitor)`
`void`	`accept(Visitor visitor, boolean includeOldValues)`
`void`	`accept(Visitor visitor, ItemPath path, boolean recursive)`
`void`	`addEstimatedOldValue(V newValue)`
`void`	`addEstimatedOldValues(Collection<V> newValues)`
`void`	`addEstimatedOldValues(V... newValues)`
`boolean`	`addsAnyValue()`
`void`	`addToReplaceDelta()`
`void`	`addValuesToAdd(Collection<V> newValues)`
`void`	`addValuesToAdd(V... newValues)`
`void`	`addValuesToDelete(Collection<V> newValues)`
`void`	`addValuesToDelete(V... newValues)`
`void`	`addValueToAdd(V newValue)`
`void`	`addValueToDelete(V newValue)`
`void`	`addValueToReplace(V newValue)`
`void`	`applyDefinition(D definition)`
`void`	`applyDefinition(D itemDefinition, boolean force)`
`void`	`applyTo(Item item)`
`void`	`applyTo(Item item, ParameterizedEquivalenceStrategy strategy)`
`void`	`applyTo(PrismContainerValue containerValue)`
`void`	`applyTo(PrismContainerValue containerValue, ParameterizedEquivalenceStrategy strategy)`
`void`	`applyToMatchingPath(Item item, ParameterizedEquivalenceStrategy strategy)`	Applies delta to item were path of the delta and path of the item matches (skips path checks).
`void`	`assertDefinitions(boolean tolarateRawValues, String sourceDescription)`
`void`	`assertDefinitions(String sourceDescription)`
`void`	`checkConsistence()`
`void`	`checkConsistence(boolean requireDefinition, boolean prohibitRaw, ConsistencyCheckScope scope)`
`void`	`checkConsistence(ConsistencyCheckScope scope)`
`void`	`checkImmutability()`
`protected void`	`checkMutability()`
`void`	`clear()`
`void`	`clearValuesToAdd()`
`void`	`clearValuesToDelete()`
`void`	`clearValuesToReplace()`
`abstract ItemDeltaImpl<V,D>`	`clone()`
`ItemDeltaImpl<V,D>`	`cloneWithChangedParentPath(ItemPath newParentPath)`
`boolean`	`contains(ItemDelta<V,D> other)`	Returns true if the other delta is a complete subset of this delta.
`boolean`	`contains(ItemDelta<V,D> other, EquivalenceStrategy strategy)`	Returns true if the other delta is a complete subset of this delta.
`protected boolean`	`containsEquivalentValue(Collection<V> collection, V value)`
`protected void`	`copyValues(ItemDeltaImpl<V,D> clone)`
`ItemDelta<V,D>`	`createReverseDelta()`
`String`	`debugDump(int indent)`
`void`	`distributeReplace(Collection<V> existingValues)`	Distributes the replace values of this delta to add and delete with respect to provided existing values.
`protected void`	`dumpValues(StringBuilder sb, String label, Collection<V> values, int indent)`
`boolean`	`equals(Object obj)`
`boolean`	`equivalent(ItemDelta other)`	Deltas are equivalent if they have the same result when applied to an object.
`void`	`filterValues(Function<V,Boolean> function)`
`V`	`findValueToAddOrReplace(V value)`
`void`	`foreach(Processor<V> processor)`	Will call processor for every element in the instance.
`V`	`getAnyValue()`
`D`	`getDefinition()`
`ItemName`	`getElementName()`
`Collection<V>`	`getEstimatedOldValues()`	Returns estimated state of the old value before the delta is applied.
`abstract Class<? extends Item>`	`getItemClass()`
`Item<V,D>`	`getItemNew()`	Returns the "new" state of the property - the state that would be after the delta is applied.
`Item<V,D>`	`getItemNew(Item<V,D> itemOld)`	Returns the "new" state of the property - the state that would be after the delta is applied.
`Item<V,D>`	`getItemNewMatchingPath(Item<V,D> itemOld)`	Returns the "new" state of the property - the state that would be after the delta is applied.
`ItemPath`	`getParentPath()`
`ItemPath`	`getPath()`
`PrismContext`	`getPrismContext()`
`ItemDelta<?,?>`	`getSubDelta(ItemPath path)`
`Collection<V>`	`getValueChanges(PlusMinusZero mode)`
`Collection<V>`	`getValuesToAdd()`
`Collection<V>`	`getValuesToDelete()`
`Collection<V>`	`getValuesToReplace()`
`boolean`	`hasCompleteDefinition()`
`int`	`hashCode()`
`boolean`	`isAdd()`
`boolean`	`isApplicableTo(Item item)`
`protected abstract boolean`	`isApplicableToType(Item item)`
`boolean`	`isDelete()`
`boolean`	`isEmpty()`
`boolean`	`isImmutable()`
`boolean`	`isInFactEmpty()`
`boolean`	`isRaw()`
`boolean`	`isRedundant(PrismObject<? extends Objectable> object, boolean assumeMissingItems)`	Checks if the delta is redundant w.r.t.
`boolean`	`isRedundant(PrismObject<? extends Objectable> object, Comparator<V> comparator, boolean assumeMissingItems)`
`boolean`	`isReplace()`
`protected boolean`	`isValueEquivalent(V a, V b)`
`boolean`	`isValueToAdd(V value)`
`boolean`	`isValueToAdd(V value, boolean ignoreMetadata)`
`boolean`	`isValueToDelete(V value)`
`boolean`	`isValueToDelete(V value, boolean ignoreMetadata)`
`boolean`	`isValueToReplace(V value)`
`boolean`	`isValueToReplace(V value, boolean ignoreMetadata)`
`void`	`merge(ItemDelta<V,D> deltaToMerge)`	Merge specified delta to this delta.
`void`	`mergeValuesToAdd(Collection<V> newValues)`
`void`	`mergeValuesToAdd(V[] newValues)`
`void`	`mergeValuesToDelete(Collection<V> newValues)`
`void`	`mergeValuesToDelete(V[] newValues)`
`void`	`mergeValuesToReplace(Collection<V> newValues)`
`void`	`mergeValuesToReplace(V[] newValues)`
`void`	`mergeValueToAdd(V newValue)`
`void`	`mergeValueToDelete(V newValue)`
`void`	`mergeValueToReplace(V newValue)`
`ItemDelta<V,D>`	`narrow(PrismObject<? extends Objectable> object, boolean assumeMissingItems)`	Filters out all delta values that are meaningless to apply.
`ItemDelta<V,D>`	`narrow(PrismObject<? extends Objectable> object, Comparator<V> comparator, boolean assumeMissingItems)`	Filters out all delta values that are meaningless to apply.
`void`	`normalize()`
`boolean`	`removeValueToAdd(PrismValue valueToRemove)`
`boolean`	`removeValueToDelete(PrismValue valueToRemove)`
`boolean`	`removeValueToReplace(PrismValue valueToRemove)`
`void`	`resetValuesToAdd()`
`void`	`resetValuesToDelete()`
`void`	`resetValuesToReplace()`
`void`	`revive(PrismContext prismContext)`
`void`	`setDefinition(D definition)`
`void`	`setElementName(QName elementName)`
`void`	`setEstimatedOldValues(Collection<V> estimatedOldValues)`
`void`	`setImmutable(boolean immutable)`
`void`	`setOriginTypeRecursive(OriginType originType)`	Set origin type to all values and subvalues
`void`	`setParentPath(ItemPath parentPath)`
`void`	`setValuesToReplace(Collection<V> newValues)`
`void`	`setValuesToReplace(V... newValues)`
`void`	`setValueToReplace()`	Sets empty value to replace.
`void`	`setValueToReplace(V newValue)`
`void`	`simplify()`	Transforms the delta to the simplest (and safest) form.
`int`	`size()`
`PrismValueDeltaSetTriple<V>`	`toDeltaSetTriple()`
`PrismValueDeltaSetTriple<V>`	`toDeltaSetTriple(Item<V,D> itemOld)`
`String`	`toString()`
`void`	`validate()`
`void`	`validate(String contextDescription)`
`void`	`validateValues(ItemDeltaValidator<V> validator)`
`void`	`validateValues(ItemDeltaValidator<V> validator, Collection<V> oldValues)`

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

- Field Detail
  - elementName
```
protected ItemName elementName
```
    Name of the property
  - parentPath
```
protected ItemPath parentPath
```
    Parent path of the property (path to the property container)
  - fullPath
```
protected ItemPath fullPath
```
  - definition
```
protected D extends ItemDefinition definition
```
  - valuesToReplace
```
protected Collection<V extends PrismValue> valuesToReplace
```
  - valuesToAdd
```
protected Collection<V extends PrismValue> valuesToAdd
```
  - valuesToDelete
```
protected Collection<V extends PrismValue> valuesToDelete
```
  - estimatedOldValues
```
protected Collection<V extends PrismValue> estimatedOldValues
```
- Constructor Detail
  - ItemDeltaImpl
```
protected ItemDeltaImpl(D itemDefinition,
                        PrismContext prismContext)
```
  - ItemDeltaImpl
```
protected ItemDeltaImpl(QName elementName,
                        D itemDefinition,
                        PrismContext prismContext)
```
  - ItemDeltaImpl
```
protected ItemDeltaImpl(ItemPath itemPath,
                        QName elementName,
                        D itemDefinition,
                        PrismContext prismContext)
```
  - ItemDeltaImpl
```
protected ItemDeltaImpl(ItemPath path,
                        D itemDefinition,
                        PrismContext prismContext)
```
- Method Detail
  - getElementName
```
public ItemName getElementName()
```
    Specified by:
    
    getElementName in interface Itemable
    
    Specified by:
    
    getElementName in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setElementName
```
public void setElementName(QName elementName)
```
    Specified by:
    
    setElementName in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getParentPath
```
public ItemPath getParentPath()
```
    Specified by:
    
    getParentPath in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setParentPath
```
public void setParentPath(ItemPath parentPath)
```
    Specified by:
    
    setParentPath in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getPath
```
@NotNull
public ItemPath getPath()
```
    Specified by:
    
    getPath in interface Itemable
    
    Specified by:
    
    getPath in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getDefinition
```
public D getDefinition()
```
    Specified by:
    
    getDefinition in interface Itemable
    
    Specified by:
    
    getDefinition in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setDefinition
```
public void setDefinition(D definition)
```
    Specified by:
    
    setDefinition in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - accept
```
public void accept(Visitor visitor)
```
    Specified by:
    
    accept in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Specified by:
    
    accept in interface Visitable<V extends PrismValue>
  - accept
```
public void accept(Visitor visitor,
                   boolean includeOldValues)
```
    Specified by:
    
    accept in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - size
```
public int size()
```
    Specified by:
    
    size in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - accept
```
public void accept(Visitor visitor,
                   ItemPath path,
                   boolean recursive)
```
    Specified by:
    
    accept in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Specified by:
    
    accept in interface PathVisitable
  - applyDefinition
```
public void applyDefinition(D definition)
                     throws SchemaException
```
    Specified by:
    
    applyDefinition in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - hasCompleteDefinition
```
public boolean hasCompleteDefinition()
```
    Specified by:
    
    hasCompleteDefinition in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getPrismContext
```
public PrismContext getPrismContext()
```
    Specified by:
    
    getPrismContext in interface Itemable
    
    Specified by:
    
    getPrismContext in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getItemClass
```
public abstract Class<? extends Item> getItemClass()
```
    Specified by:
    
    getItemClass in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getValuesToAdd
```
public Collection<V> getValuesToAdd()
```
    Specified by:
    
    getValuesToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - clearValuesToAdd
```
public void clearValuesToAdd()
```
    Specified by:
    
    clearValuesToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getValuesToDelete
```
public Collection<V> getValuesToDelete()
```
    Specified by:
    
    getValuesToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - clearValuesToDelete
```
public void clearValuesToDelete()
```
    Specified by:
    
    clearValuesToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getValuesToReplace
```
public Collection<V> getValuesToReplace()
```
    Specified by:
    
    getValuesToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - clearValuesToReplace
```
public void clearValuesToReplace()
```
    Specified by:
    
    clearValuesToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addValuesToAdd
```
public void addValuesToAdd(Collection<V> newValues)
```
    Specified by:
    
    addValuesToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addValuesToAdd
```
public void addValuesToAdd(V... newValues)
```
    Specified by:
    
    addValuesToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addValueToAdd
```
public void addValueToAdd(V newValue)
```
    Specified by:
    
    addValueToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - removeValueToAdd
```
public boolean removeValueToAdd(PrismValue valueToRemove)
```
    Specified by:
    
    removeValueToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - removeValueToDelete
```
public boolean removeValueToDelete(PrismValue valueToRemove)
```
    Specified by:
    
    removeValueToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - removeValueToReplace
```
public boolean removeValueToReplace(PrismValue valueToRemove)
```
    Specified by:
    
    removeValueToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValuesToAdd
```
public void mergeValuesToAdd(Collection<V> newValues)
```
    Specified by:
    
    mergeValuesToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValuesToAdd
```
public void mergeValuesToAdd(V[] newValues)
```
    Specified by:
    
    mergeValuesToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValueToAdd
```
public void mergeValueToAdd(V newValue)
```
    Specified by:
    
    mergeValueToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addValuesToDelete
```
public void addValuesToDelete(Collection<V> newValues)
```
    Specified by:
    
    addValuesToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addValuesToDelete
```
public void addValuesToDelete(V... newValues)
```
    Specified by:
    
    addValuesToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addValueToDelete
```
public void addValueToDelete(V newValue)
```
    Specified by:
    
    addValueToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - containsEquivalentValue
```
protected boolean containsEquivalentValue(Collection<V> collection,
                                          V value)
```
  - isValueEquivalent
```
protected boolean isValueEquivalent(V a,
                                    V b)
```
  - mergeValuesToDelete
```
public void mergeValuesToDelete(Collection<V> newValues)
```
    Specified by:
    
    mergeValuesToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValuesToDelete
```
public void mergeValuesToDelete(V[] newValues)
```
    Specified by:
    
    mergeValuesToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValueToDelete
```
public void mergeValueToDelete(V newValue)
```
    Specified by:
    
    mergeValueToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - resetValuesToAdd
```
public void resetValuesToAdd()
```
    Specified by:
    
    resetValuesToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - resetValuesToDelete
```
public void resetValuesToDelete()
```
    Specified by:
    
    resetValuesToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - resetValuesToReplace
```
public void resetValuesToReplace()
```
    Specified by:
    
    resetValuesToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setValuesToReplace
```
public void setValuesToReplace(Collection<V> newValues)
```
    Specified by:
    
    setValuesToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setValuesToReplace
```
public void setValuesToReplace(V... newValues)
```
    Specified by:
    
    setValuesToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setValueToReplace
```
public void setValueToReplace()
```
    Sets empty value to replace. This efficiently means removing all values.
    
    Specified by:
    
    setValueToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setValueToReplace
```
public void setValueToReplace(V newValue)
```
    Specified by:
    
    setValueToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addValueToReplace
```
public void addValueToReplace(V newValue)
```
    Specified by:
    
    addValueToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValuesToReplace
```
public void mergeValuesToReplace(Collection<V> newValues)
```
    Specified by:
    
    mergeValuesToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValuesToReplace
```
public void mergeValuesToReplace(V[] newValues)
```
    Specified by:
    
    mergeValuesToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - mergeValueToReplace
```
public void mergeValueToReplace(V newValue)
```
    Specified by:
    
    mergeValueToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isValueToAdd
```
public boolean isValueToAdd(V value)
```
    Specified by:
    
    isValueToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isValueToAdd
```
public boolean isValueToAdd(V value,
                            boolean ignoreMetadata)
```
    Specified by:
    
    isValueToAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isValueToDelete
```
public boolean isValueToDelete(V value)
```
    Specified by:
    
    isValueToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isValueToDelete
```
public boolean isValueToDelete(V value,
                               boolean ignoreMetadata)
```
    Specified by:
    
    isValueToDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isValueToReplace
```
public boolean isValueToReplace(V value)
```
    Specified by:
    
    isValueToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isValueToReplace
```
public boolean isValueToReplace(V value,
                                boolean ignoreMetadata)
```
    Specified by:
    
    isValueToReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getAnyValue
```
public V getAnyValue()
```
    Specified by:
    
    getAnyValue in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isInFactEmpty
```
public boolean isInFactEmpty()
```
    Specified by:
    
    isInFactEmpty in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addsAnyValue
```
public boolean addsAnyValue()
```
    Specified by:
    
    addsAnyValue in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - foreach
```
public void foreach(Processor<V> processor)
```
    Description copied from interface: Foreachable
    
    Will call processor for every element in the instance. This is NOT recursive. E.g. in case of collection of collections the processor will NOT be called for elements of the inner collections. If you need recursion please have a look at Visitor.
    
    Specified by:
    
    foreach in interface Foreachable<V extends PrismValue>
    
    Specified by:
    
    foreach in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getEstimatedOldValues
```
public Collection<V> getEstimatedOldValues()
```
    Returns estimated state of the old value before the delta is applied. This information is not entirely reliable. The state might change between the value is read and the delta is applied. This is property is optional and even if provided it is only for for informational purposes. If this method returns null then it should be interpreted as "I do not know". In that case the delta has no information about the old values. If this method returns empty collection then it should be interpreted that we know that there were no values in this item before the delta was applied.
    
    Specified by:
    
    getEstimatedOldValues in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Returns:
    
    estimated state of the old value before the delta is applied (may be null).
  - setEstimatedOldValues
```
public void setEstimatedOldValues(Collection<V> estimatedOldValues)
```
    Specified by:
    
    setEstimatedOldValues in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addEstimatedOldValues
```
public void addEstimatedOldValues(Collection<V> newValues)
```
    Specified by:
    
    addEstimatedOldValues in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addEstimatedOldValues
```
public void addEstimatedOldValues(V... newValues)
```
    Specified by:
    
    addEstimatedOldValues in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - addEstimatedOldValue
```
public void addEstimatedOldValue(V newValue)
```
    Specified by:
    
    addEstimatedOldValue in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - normalize
```
public void normalize()
```
    Specified by:
    
    normalize in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isReplace
```
public boolean isReplace()
```
    Specified by:
    
    isReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isAdd
```
public boolean isAdd()
```
    Specified by:
    
    isAdd in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isDelete
```
public boolean isDelete()
```
    Specified by:
    
    isDelete in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - narrow
```
public ItemDelta<V,D> narrow(PrismObject<? extends Objectable> object,
                                   boolean assumeMissingItems)
```
    Filters out all delta values that are meaningless to apply. E.g. removes all values to add that the property already has, removes all values to delete that the property does not have, etc. Returns null if the delta is not needed at all.
    
    Specified by:
    
    narrow in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Parameters:
    
    assumeMissingItems - Assumes that some items in the object may be missing. So replacing them by null or deleting some values from them cannot be narrowed out.
  - narrow
```
public ItemDelta<V,D> narrow(PrismObject<? extends Objectable> object,
                                   Comparator<V> comparator,
                                   boolean assumeMissingItems)
```
    Filters out all delta values that are meaningless to apply. E.g. removes all values to add that the property already has, removes all values to delete that the property does not have, etc. Returns null if the delta is not needed at all.
    
    Specified by:
    
    narrow in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Parameters:
    
    assumeMissingItems - Assumes that some items in the object may be missing. So replacing them by null or deleting some values from them cannot be narrowed out.
  - isRedundant
```
public boolean isRedundant(PrismObject<? extends Objectable> object,
                           boolean assumeMissingItems)
```
    Checks if the delta is redundant w.r.t. current state of the object. I.e. if it changes the current object state.
    
    Specified by:
    
    isRedundant in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    assumeMissingItems - Assumes that some items in the object may be missing. So delta that replaces them by null or deletes some values from them cannot be considered redundant.
  - isRedundant
```
public boolean isRedundant(PrismObject<? extends Objectable> object,
                           Comparator<V> comparator,
                           boolean assumeMissingItems)
```
    Specified by:
    
    isRedundant in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    assumeMissingItems - Assumes that some items in the object may be missing. So delta that replaces them by null or deletes some values from them cannot be considered redundant.
  - validate
```
public void validate()
              throws SchemaException
```
    Specified by:
    
    validate in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - validate
```
public void validate(String contextDescription)
              throws SchemaException
```
    Specified by:
    
    validate in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - validateValues
```
public void validateValues(ItemDeltaValidator<V> validator)
                    throws SchemaException
```
    Specified by:
    
    validateValues in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - validateValues
```
public void validateValues(ItemDeltaValidator<V> validator,
                           Collection<V> oldValues)
                    throws SchemaException
```
    Specified by:
    
    validateValues in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - checkConsistence
```
public void checkConsistence()
```
    Specified by:
    
    checkConsistence in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - checkConsistence
```
public void checkConsistence(ConsistencyCheckScope scope)
```
    Specified by:
    
    checkConsistence in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - checkConsistence
```
public void checkConsistence(boolean requireDefinition,
                             boolean prohibitRaw,
                             ConsistencyCheckScope scope)
```
    Specified by:
    
    checkConsistence in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - distributeReplace
```
public void distributeReplace(Collection<V> existingValues)
```
    Distributes the replace values of this delta to add and delete with respect to provided existing values.
    
    Specified by:
    
    distributeReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - merge
```
public void merge(ItemDelta<V,D> deltaToMerge)
```
    Merge specified delta to this delta. This delta is assumed to be chronologically earlier, delta provided in the parameter is chronologically later. TODO do we expect that the paths of "this" delta and deltaToMerge are the same? From the code it seems so.
    
    Specified by:
    
    merge in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - getValueChanges
```
public Collection<V> getValueChanges(PlusMinusZero mode)
```
    Specified by:
    
    getValueChanges in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - simplify
```
public void simplify()
```
    Transforms the delta to the simplest (and safest) form. E.g. it will transform add delta for single-value properties to replace delta.
    
    Specified by:
    
    simplify in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - applyTo
```
public void applyTo(PrismContainerValue containerValue)
             throws SchemaException
```
    Specified by:
    
    applyTo in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - applyTo
```
public void applyTo(PrismContainerValue containerValue,
                    ParameterizedEquivalenceStrategy strategy)
             throws SchemaException
```
    Specified by:
    
    applyTo in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - applyTo
```
public void applyTo(Item item)
             throws SchemaException
```
    Specified by:
    
    applyTo in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - applyTo
```
public void applyTo(Item item,
                    ParameterizedEquivalenceStrategy strategy)
             throws SchemaException
```
    Specified by:
    
    applyTo in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - applyToMatchingPath
```
public void applyToMatchingPath(Item item,
                                ParameterizedEquivalenceStrategy strategy)
                         throws SchemaException
```
    Applies delta to item were path of the delta and path of the item matches (skips path checks).
    
    Specified by:
    
    applyToMatchingPath in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - getSubDelta
```
public ItemDelta<?,?> getSubDelta(ItemPath path)
```
    Specified by:
    
    getSubDelta in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isApplicableTo
```
public boolean isApplicableTo(Item item)
```
    Specified by:
    
    isApplicableTo in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isApplicableToType
```
protected abstract boolean isApplicableToType(Item item)
```
  - getItemNew
```
public Item<V,D> getItemNew()
                           throws SchemaException
```
    Returns the "new" state of the property - the state that would be after the delta is applied. WARNING: Output of this method should be used for preview only. It should NOT be placed into prism structures. Not even cloned. This method may return dummy items or similar items that are not usable. Values in the items should be OK, but they may need cloning.
    
    Specified by:
    
    getItemNew in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - getItemNew
```
public Item<V,D> getItemNew(Item<V,D> itemOld)
                           throws SchemaException
```
    Returns the "new" state of the property - the state that would be after the delta is applied. WARNING: Output of this method should be used for preview only. It should NOT be placed into prism structures. Not even cloned. This method may return dummy items or similar items that are not usable. Values in the items should be OK, but they may need cloning.
    
    Specified by:
    
    getItemNew in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - getItemNewMatchingPath
```
public Item<V,D> getItemNewMatchingPath(Item<V,D> itemOld)
                                       throws SchemaException
```
    Returns the "new" state of the property - the state that would be after the delta is applied. WARNING: This is supposed to work only if the paths of the the delta and the item matches. E.g. it is NOT usable for application of subdeltas to containers.
    
    Specified by:
    
    getItemNewMatchingPath in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - contains
```
public boolean contains(ItemDelta<V,D> other)
```
    Returns true if the other delta is a complete subset of this delta. I.e. if all the statements of the other delta are already contained in this delta. As a consequence it also returns true if the two deltas are equal.
    
    Specified by:
    
    contains in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - contains
```
public boolean contains(ItemDelta<V,D> other,
                        EquivalenceStrategy strategy)
```
    Returns true if the other delta is a complete subset of this delta. I.e. if all the statements of the other delta are already contained in this delta. As a consequence it also returns true if the two deltas are equal.
    
    Specified by:
    
    contains in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - filterValues
```
public void filterValues(Function<V,Boolean> function)
```
    Specified by:
    
    filterValues in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - clone
```
public abstract ItemDeltaImpl<V,D> clone()
```
    Specified by:
    
    clone in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Overrides:
    
    clone in class Object
  - cloneWithChangedParentPath
```
public ItemDeltaImpl<V,D> cloneWithChangedParentPath(ItemPath newParentPath)
```
    Specified by:
    
    cloneWithChangedParentPath in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - copyValues
```
protected void copyValues(ItemDeltaImpl<V,D> clone)
```
  - toDeltaSetTriple
```
public PrismValueDeltaSetTriple<V> toDeltaSetTriple()
```
    Specified by:
    
    toDeltaSetTriple in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - toDeltaSetTriple
```
public PrismValueDeltaSetTriple<V> toDeltaSetTriple(Item<V,D> itemOld)
```
    Specified by:
    
    toDeltaSetTriple in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - assertDefinitions
```
public void assertDefinitions(String sourceDescription)
                       throws SchemaException
```
    Specified by:
    
    assertDefinitions in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - assertDefinitions
```
public void assertDefinitions(boolean tolarateRawValues,
                              String sourceDescription)
                       throws SchemaException
```
    Specified by:
    
    assertDefinitions in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - isRaw
```
public boolean isRaw()
```
    Specified by:
    
    isRaw in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - revive
```
public void revive(PrismContext prismContext)
            throws SchemaException
```
    Specified by:
    
    revive in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - applyDefinition
```
public void applyDefinition(D itemDefinition,
                            boolean force)
                     throws SchemaException
```
    Specified by:
    
    applyDefinition in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Throws:
    
    SchemaException
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equivalent
```
public boolean equivalent(ItemDelta other)
```
    Deltas are equivalent if they have the same result when applied to an object. I.e. meta-data and other "decorations" such as old values are not considered in this comparison.
    
    Specified by:
    
    equivalent in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - equals
```
public boolean equals(Object obj)
```
    Specified by:
    
    equals in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
    
    Overrides:
    
    toString in class Object
  - debugDump
```
public String debugDump(int indent)
```
    Specified by:
    
    debugDump in interface DebugDumpable
    
    Specified by:
    
    debugDump in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - dumpValues
```
protected void dumpValues(StringBuilder sb,
                          String label,
                          Collection<V> values,
                          int indent)
```
  - addToReplaceDelta
```
public void addToReplaceDelta()
```
    Specified by:
    
    addToReplaceDelta in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - createReverseDelta
```
public ItemDelta<V,D> createReverseDelta()
```
    Specified by:
    
    createReverseDelta in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - findValueToAddOrReplace
```
public V findValueToAddOrReplace(V value)
```
    Specified by:
    
    findValueToAddOrReplace in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setOriginTypeRecursive
```
public void setOriginTypeRecursive(OriginType originType)
```
    Set origin type to all values and subvalues
    
    Specified by:
    
    setOriginTypeRecursive in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - isImmutable
```
public boolean isImmutable()
```
    Specified by:
    
    isImmutable in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - setImmutable
```
public void setImmutable(boolean immutable)
```
    Specified by:
    
    setImmutable in interface ItemDelta<V extends PrismValue,D extends ItemDefinition>
  - checkMutability
```
protected void checkMutability()
```
  - checkImmutability
```
public void checkImmutability()
```

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

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Field Detail

elementName

parentPath

fullPath

definition

valuesToReplace

valuesToAdd

valuesToDelete

estimatedOldValues

Constructor Detail

ItemDeltaImpl

ItemDeltaImpl

ItemDeltaImpl

ItemDeltaImpl

Method Detail

getElementName

setElementName

getParentPath

setParentPath

getPath

getDefinition

setDefinition

accept

accept

size

accept

applyDefinition

hasCompleteDefinition

getPrismContext

getItemClass

getValuesToAdd

clearValuesToAdd

getValuesToDelete

clearValuesToDelete

getValuesToReplace

clearValuesToReplace

addValuesToAdd

addValuesToAdd

addValueToAdd

removeValueToAdd

removeValueToDelete

removeValueToReplace

mergeValuesToAdd

mergeValuesToAdd

mergeValueToAdd

addValuesToDelete

addValuesToDelete

addValueToDelete

containsEquivalentValue

isValueEquivalent

mergeValuesToDelete

mergeValuesToDelete

mergeValueToDelete

resetValuesToAdd

resetValuesToDelete

resetValuesToReplace

setValuesToReplace

setValuesToReplace

setValueToReplace

setValueToReplace

addValueToReplace

mergeValuesToReplace

mergeValuesToReplace

mergeValueToReplace

isValueToAdd

isValueToAdd

isValueToDelete

isValueToDelete

isValueToReplace

isValueToReplace

getAnyValue

isEmpty

isInFactEmpty

Class ItemDeltaImpl<V extends PrismValue,D extends ItemDefinition>