com.evolveum.midpoint.prism.delta

Class ItemDelta<V extends PrismValue,D extends ItemDefinition>

java.lang.Object

com.evolveum.midpoint.prism.delta.ItemDelta<V,D>

All Implemented Interfaces:

Itemable, PathVisitable, Visitable, DebugDumpable, Serializable

Direct Known Subclasses:

ContainerDelta, PropertyDelta, ReferenceDelta

public abstract class ItemDelta<V extends PrismValue,D extends ItemDefinition>
extends Object
implements Itemable, DebugDumpable, Visitable, PathVisitable, Serializable

Author:

Radovan Semancik

See Also:

Serialized Form

Field Summary

Fields

Modifier and Type	Field and Description
protected D	definition
protected QName	elementName Name of the property
protected Collection<V>	estimatedOldValues
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 and Description
protected	ItemDelta(D itemDefinition, PrismContext prismContext)
protected	ItemDelta(ItemPath path, D itemDefinition, PrismContext prismContext)
protected	ItemDelta(ItemPath parentPath, QName elementName, D itemDefinition, PrismContext prismContext)
protected	ItemDelta(QName elementName, D itemDefinition, PrismContext prismContext)

Method Summary

Methods

Modifier and Type	Method and Description
static void	accept(Collection<? extends ItemDelta> modifications, Visitor visitor, ItemPath path, boolean recursive)
void	accept(Visitor visitor)
void	accept(Visitor visitor, boolean includeOldValues)
void	accept(Visitor visitor, ItemPath path, boolean recursive)
static void	addAll(Collection<? extends ItemDelta> modifications, Collection<? extends ItemDelta> deltasToAdd)
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)
static void	applyDefinition(Collection<? extends ItemDelta> deltas, PrismObjectDefinition definition)
void	applyDefinition(D definition)
void	applyDefinition(D itemDefinition, boolean force)
static void	applyTo(Collection<? extends ItemDelta> deltas, PrismContainer propertyContainer)
void	applyTo(Item item)
void	applyTo(PrismContainerValue containerValue)
static void	applyToMatchingPath(Collection<? extends ItemDelta> deltas, PrismContainer propertyContainer)
void	applyToMatchingPath(Item item) 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)
static void	checkConsistence(Collection<? extends ItemDelta> deltas)
static void	checkConsistence(Collection<? extends ItemDelta> deltas, boolean requireDefinition, boolean prohibitRaw, ConsistencyCheckScope scope)
static void	checkConsistence(Collection<? extends ItemDelta> deltas, ConsistencyCheckScope scope)
void	checkConsistence(ConsistencyCheckScope scope)
void	clear()
void	clearValuesToAdd()
void	clearValuesToDelete()
void	clearValuesToReplace()
abstract ItemDelta<V,D>	clone()
static <D extends ItemDelta<?,?>> Collection<D>	cloneCollection(Collection<D> orig)
boolean	contains(ItemDelta<V,D> other) Returns true if the other delta is a complete subset of this delta.
protected boolean	containsEquivalentValue(Collection<V> collection, V value)
protected void	copyValues(ItemDelta<V,D> clone)
String	debugDump() Show the content of the object intended for diagnostics by system administrator.
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.
static <X extends Containerable> ContainerDelta<X>	findContainerDelta(Collection<? extends ItemDelta> deltas, ItemPath propertyPath)
static <X extends Containerable> ContainerDelta<X>	findContainerDelta(Collection<? extends ItemDelta> deltas, QName name)
static <DD extends ItemDelta> DD	findItemDelta(Collection<? extends ItemDelta> deltas, ItemPath propertyPath, Class<DD> deltaType)
static <D extends ItemDelta> D	findItemDelta(Collection<? extends ItemDelta> deltas, QName itemName, Class<D> deltaType)
static Collection<? extends ItemDelta<?,?>>	findItemDeltasSubPath(Collection<? extends ItemDelta<?,?>> deltas, ItemPath itemPath)
static <T> PropertyDelta<T>	findPropertyDelta(Collection<? extends ItemDelta> deltas, ItemPath propertyPath)
static <T> PropertyDelta<T>	findPropertyDelta(Collection<? extends ItemDelta> deltas, ItemPath parentPath, QName propertyName)
static <T> PropertyDelta<T>	findPropertyDelta(Collection<? extends ItemDelta> deltas, QName propertyName)
static ReferenceDelta	findReferenceModification(Collection<? extends ItemDelta> deltas, QName itemName)
V	getAnyValue()
D	getDefinition()
QName	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)
ItemPath	getParentPath()
ItemPath	getPath()
PrismContext	getPrismContext()
ItemDelta<?,?>	getSubDelta(ItemPath path)
Collection<V>	getValuesToAdd()
Collection<V>	getValuesToDelete()
Collection<V>	getValuesToReplace()
boolean	hasCompleteDefinition()
static boolean	hasEquivalent(Collection<? extends ItemDelta> col, ItemDelta delta)
int	hashCode()
boolean	isAdd()
boolean	isApplicableTo(Item item)
protected abstract boolean	isApplicableToType(Item item)
boolean	isDelete()
boolean	isEmpty()
static boolean	isEmpty(ItemDeltaType itemDeltaType)
boolean	isRaw()
boolean	isRedundant(PrismObject<? extends Objectable> object) Checks if the delta is redundant w.r.t.
boolean	isRedundant(PrismObject<? extends Objectable> object, Comparator<V> comparator)
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)
static void	merge(Collection<? extends ItemDelta> modifications, ItemDelta delta)
void	merge(ItemDelta<V,D> deltaToMerge) Merge specified delta to this delta.
static void	mergeAll(Collection<? extends ItemDelta> modifications, Collection<? extends ItemDelta> deltasToMerge)
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) Filters out all delta values that are meaningless to apply.
ItemDelta<V,D>	narrow(PrismObject<? extends Objectable> object, Comparator<V> comparator) Filters out all delta values that are meaningless to apply.
void	normalize()
static <D extends ItemDelta> void	removeItemDelta(Collection<? extends ItemDelta> deltas, ItemDelta deltaToRemove)
static <D extends ItemDelta> void	removeItemDelta(Collection<? extends ItemDelta> deltas, ItemPath propertyPath, Class<D> deltaType)
boolean	removeValueToAdd(V valueToRemove)
boolean	removeValueToDelete(V valueToRemove)
boolean	removeValueToReplace(V 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	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.
PrismValueDeltaSetTriple<V>	toDeltaSetTriple()
static <IV extends PrismValue,ID extends ItemDefinition> PrismValueDeltaSetTriple<IV>	toDeltaSetTriple(Item<IV,ID> item, ItemDelta<IV,ID> delta)
static <IV extends PrismValue,ID extends ItemDefinition> PrismValueDeltaSetTriple<IV>	toDeltaSetTriple(Item<IV,ID> item, ItemDelta<IV,ID> delta, boolean oldValuesValid, boolean newValuesValid) Deprecated.
PrismValueDeltaSetTriple<V>	toDeltaSetTriple(Item<V,D> itemOld)
String	toString()
void	validate()
void	validate(String contextDescription)

Methods inherited from class java.lang.Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

elementName

protected QName elementName

Name of the property

parentPath

protected ItemPath parentPath

Parent path of the property (path to the property container)

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

ItemDelta

protected ItemDelta(D itemDefinition,
         PrismContext prismContext)

ItemDelta

protected ItemDelta(QName elementName,
         D itemDefinition,
         PrismContext prismContext)

ItemDelta

protected ItemDelta(ItemPath parentPath,
         QName elementName,
         D itemDefinition,
         PrismContext prismContext)

ItemDelta

protected ItemDelta(ItemPath path,
         D itemDefinition,
         PrismContext prismContext)

Method Detail

getElementName

public QName getElementName()

Specified by:

getElementName in interface Itemable

setElementName

public void setElementName(QName elementName)

getParentPath

public ItemPath getParentPath()

setParentPath

public void setParentPath(ItemPath parentPath)

getPath

public ItemPath getPath()

Specified by:

getPath in interface Itemable

getDefinition

public D getDefinition()

Specified by:

getDefinition in interface Itemable

setDefinition

public void setDefinition(D definition)

accept

public void accept(Visitor visitor)

Specified by:

accept in interface Visitable

accept

public void accept(Visitor visitor,
          boolean includeOldValues)

accept

public void accept(Visitor visitor,
          ItemPath path,
          boolean recursive)

Specified by:

accept in interface PathVisitable

applyDefinition

public void applyDefinition(D definition)
                     throws SchemaException

Throws:

SchemaException

applyDefinition

public static void applyDefinition(Collection<? extends ItemDelta> deltas,
                   PrismObjectDefinition definition)
                            throws SchemaException

Throws:

SchemaException

hasCompleteDefinition

public boolean hasCompleteDefinition()

getPrismContext

public PrismContext getPrismContext()

Specified by:

getPrismContext in interface Itemable

getItemClass

public abstract Class<? extends Item> getItemClass()

getValuesToAdd

public Collection<V> getValuesToAdd()

clearValuesToAdd

public void clearValuesToAdd()

getValuesToDelete

public Collection<V> getValuesToDelete()

clearValuesToDelete

public void clearValuesToDelete()

getValuesToReplace

public Collection<V> getValuesToReplace()

clearValuesToReplace

public void clearValuesToReplace()

addValuesToAdd

public void addValuesToAdd(Collection<V> newValues)

addValuesToAdd

public void addValuesToAdd(V... newValues)

addValueToAdd

public void addValueToAdd(V newValue)

removeValueToAdd

public boolean removeValueToAdd(V valueToRemove)

removeValueToDelete

public boolean removeValueToDelete(V valueToRemove)

removeValueToReplace

public boolean removeValueToReplace(V valueToRemove)

mergeValuesToAdd

public void mergeValuesToAdd(Collection<V> newValues)

mergeValuesToAdd

public void mergeValuesToAdd(V[] newValues)

mergeValueToAdd

public void mergeValueToAdd(V newValue)

addValuesToDelete

public void addValuesToDelete(Collection<V> newValues)

addValuesToDelete

public void addValuesToDelete(V... newValues)

addValueToDelete

public void addValueToDelete(V newValue)

containsEquivalentValue

protected boolean containsEquivalentValue(Collection<V> collection,
                              V value)

isValueEquivalent

protected boolean isValueEquivalent(V a,
                        V b)

mergeValuesToDelete

public void mergeValuesToDelete(Collection<V> newValues)

mergeValuesToDelete

public void mergeValuesToDelete(V[] newValues)

mergeValueToDelete

public void mergeValueToDelete(V newValue)

resetValuesToAdd

public void resetValuesToAdd()

resetValuesToDelete

public void resetValuesToDelete()

resetValuesToReplace

public void resetValuesToReplace()

setValuesToReplace

public void setValuesToReplace(Collection<V> newValues)

setValuesToReplace

public void setValuesToReplace(V... newValues)

setValueToReplace

public void setValueToReplace()

Sets empty value to replace. This efficiently means removing all values.

setValueToReplace

public void setValueToReplace(V newValue)

addValueToReplace

public void addValueToReplace(V newValue)

mergeValuesToReplace

public void mergeValuesToReplace(Collection<V> newValues)

mergeValuesToReplace

public void mergeValuesToReplace(V[] newValues)

mergeValueToReplace

public void mergeValueToReplace(V newValue)

isValueToAdd

public boolean isValueToAdd(V value)

isValueToAdd

public boolean isValueToAdd(V value,
                   boolean ignoreMetadata)

isValueToDelete

public boolean isValueToDelete(V value)

isValueToDelete

public boolean isValueToDelete(V value,
                      boolean ignoreMetadata)

isValueToReplace

public boolean isValueToReplace(V value)

isValueToReplace

public boolean isValueToReplace(V value,
                       boolean ignoreMetadata)

getAnyValue

public V getAnyValue()

isEmpty

public boolean isEmpty()

isEmpty

public static boolean isEmpty(ItemDeltaType itemDeltaType)

addsAnyValue

public boolean addsAnyValue()

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.

Returns:

estimated state of the old value before the delta is applied (may be null).

setEstimatedOldValues

public void setEstimatedOldValues(Collection<V> estimatedOldValues)

addEstimatedOldValues

public void addEstimatedOldValues(Collection<V> newValues)

addEstimatedOldValues

public void addEstimatedOldValues(V... newValues)

addEstimatedOldValue

public void addEstimatedOldValue(V newValue)

normalize

public void normalize()

isReplace

public boolean isReplace()

isAdd

public boolean isAdd()

isDelete

public boolean isDelete()

clear

public void clear()

findPropertyDelta

public static <T> PropertyDelta<T> findPropertyDelta(Collection<? extends ItemDelta> deltas,
                                     QName propertyName)

findPropertyDelta

public static <T> PropertyDelta<T> findPropertyDelta(Collection<? extends ItemDelta> deltas,
                                     ItemPath parentPath,
                                     QName propertyName)

findPropertyDelta

public static <T> PropertyDelta<T> findPropertyDelta(Collection<? extends ItemDelta> deltas,
                                     ItemPath propertyPath)

findContainerDelta

public static <X extends Containerable> ContainerDelta<X> findContainerDelta(Collection<? extends ItemDelta> deltas,
                                                             ItemPath propertyPath)

findContainerDelta

public static <X extends Containerable> ContainerDelta<X> findContainerDelta(Collection<? extends ItemDelta> deltas,
                                                             QName name)

findItemDelta

public static <DD extends ItemDelta> DD findItemDelta(Collection<? extends ItemDelta> deltas,
                                      ItemPath propertyPath,
                                      Class<DD> deltaType)

findItemDeltasSubPath

public static Collection<? extends ItemDelta<?,?>> findItemDeltasSubPath(Collection<? extends ItemDelta<?,?>> deltas,
                                                         ItemPath itemPath)

findItemDelta

public static <D extends ItemDelta> D findItemDelta(Collection<? extends ItemDelta> deltas,
                                    QName itemName,
                                    Class<D> deltaType)

findReferenceModification

public static ReferenceDelta findReferenceModification(Collection<? extends ItemDelta> deltas,
                                       QName itemName)

removeItemDelta

public static <D extends ItemDelta> void removeItemDelta(Collection<? extends ItemDelta> deltas,
                                         ItemPath propertyPath,
                                         Class<D> deltaType)

removeItemDelta

public static <D extends ItemDelta> void removeItemDelta(Collection<? extends ItemDelta> deltas,
                                         ItemDelta deltaToRemove)

narrow

public ItemDelta<V,D> narrow(PrismObject<? extends Objectable> object)

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.

narrow

public ItemDelta<V,D> narrow(PrismObject<? extends Objectable> object,
                    Comparator<V> comparator)

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.

isRedundant

public boolean isRedundant(PrismObject<? extends Objectable> object)

Checks if the delta is redundant w.r.t. current state of the object. I.e. if it changes the current object state.

isRedundant

public boolean isRedundant(PrismObject<? extends Objectable> object,
                  Comparator<V> comparator)

validate

public void validate()
              throws SchemaException

Throws:

SchemaException

validate

public void validate(String contextDescription)
              throws SchemaException

Throws:

SchemaException

checkConsistence

public static void checkConsistence(Collection<? extends ItemDelta> deltas)

checkConsistence

public static void checkConsistence(Collection<? extends ItemDelta> deltas,
                    ConsistencyCheckScope scope)

checkConsistence

public static void checkConsistence(Collection<? extends ItemDelta> deltas,
                    boolean requireDefinition,
                    boolean prohibitRaw,
                    ConsistencyCheckScope scope)

checkConsistence

public void checkConsistence()

checkConsistence

public void checkConsistence(ConsistencyCheckScope scope)

checkConsistence

public void checkConsistence(boolean requireDefinition,
                    boolean prohibitRaw,
                    ConsistencyCheckScope scope)

distributeReplace

public void distributeReplace(Collection<V> existingValues)

Distributes the replace values of this delta to add and delete with respect to provided existing values.

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 chronilogically later.

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.

applyTo

public static void applyTo(Collection<? extends ItemDelta> deltas,
           PrismContainer propertyContainer)
                    throws SchemaException

Throws:

SchemaException

applyToMatchingPath

public static void applyToMatchingPath(Collection<? extends ItemDelta> deltas,
                       PrismContainer propertyContainer)
                                throws SchemaException

Throws:

SchemaException

applyTo

public void applyTo(PrismContainerValue containerValue)
             throws SchemaException

Throws:

SchemaException

applyTo

public void applyTo(Item item)
             throws SchemaException

Throws:

SchemaException

applyToMatchingPath

public void applyToMatchingPath(Item item)
                         throws SchemaException

Applies delta to item were path of the delta and path of the item matches (skips path checks).

Throws:

SchemaException

getSubDelta

public ItemDelta<?,?> getSubDelta(ItemPath path)

isApplicableTo

public boolean isApplicableTo(Item item)

isApplicableToType

protected abstract boolean isApplicableToType(Item item)

accept

public static void accept(Collection<? extends ItemDelta> modifications,
          Visitor visitor,
          ItemPath path,
          boolean recursive)

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.

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.

Throws:

SchemaException

getItemNewMatchingPath

public Item<V,D> getItemNewMatchingPath(Item<V,D> itemOld)
                                                                           throws SchemaException

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.

clone

public abstract ItemDelta<V,D> clone()

Overrides:

clone in class Object

copyValues

protected void copyValues(ItemDelta<V,D> clone)

cloneCollection

public static <D extends ItemDelta<?,?>> Collection<D> cloneCollection(Collection<D> orig)

toDeltaSetTriple

@Deprecated
public static <IV extends PrismValue,ID extends ItemDefinition> PrismValueDeltaSetTriple<IV> toDeltaSetTriple(Item<IV,ID> item,
                                                                                                         ItemDelta<IV,ID> delta,
                                                                                                         boolean oldValuesValid,
                                                                                                         boolean newValuesValid)

Deprecated.

toDeltaSetTriple

public static <IV extends PrismValue,ID extends ItemDefinition> PrismValueDeltaSetTriple<IV> toDeltaSetTriple(Item<IV,ID> item,
                                                                                              ItemDelta<IV,ID> delta)

toDeltaSetTriple

public PrismValueDeltaSetTriple<V> toDeltaSetTriple()

toDeltaSetTriple

public PrismValueDeltaSetTriple<V> toDeltaSetTriple(Item<V,D> itemOld)

assertDefinitions

public void assertDefinitions(String sourceDescription)
                       throws SchemaException

Throws:

SchemaException

assertDefinitions

public void assertDefinitions(boolean tolarateRawValues,
                     String sourceDescription)
                       throws SchemaException

Throws:

SchemaException

isRaw

public boolean isRaw()

revive

public void revive(PrismContext prismContext)
            throws SchemaException

Throws:

SchemaException

applyDefinition

public void applyDefinition(D itemDefinition,
                   boolean force)
                     throws SchemaException

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.

hasEquivalent

public static boolean hasEquivalent(Collection<? extends ItemDelta> col,
                    ItemDelta delta)

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

toString

public String toString()

Overrides:

toString in class Object

debugDump

public String debugDump()

Description copied from interface: DebugDumpable

Show the content of the object intended for diagnostics by system administrator. The out put should be suitable to use in system logs at "debug" level. It may be multi-line, but in that case it should be well indented and quite terse. As it is intended to be used by system administrator, it should not use any developer terms such as class names, exceptions or stack traces.

Specified by:

debugDump in interface DebugDumpable

Returns:

content of the object intended for diagnostics by system administrator.

debugDump

public String debugDump(int indent)

Specified by:

debugDump in interface DebugDumpable

dumpValues

protected void dumpValues(StringBuilder sb,
              String label,
              Collection<V> values,
              int indent)

addAll

public static void addAll(Collection<? extends ItemDelta> modifications,
          Collection<? extends ItemDelta> deltasToAdd)

merge

public static void merge(Collection<? extends ItemDelta> modifications,
         ItemDelta delta)

mergeAll

public static void mergeAll(Collection<? extends ItemDelta> modifications,
            Collection<? extends ItemDelta> deltasToMerge)

addToReplaceDelta

public void addToReplaceDelta()