Package com.evolveum.midpoint.prism.impl

Class ItemImpl<V extends PrismValue,D extends ItemDefinition>

java.lang.Object

com.evolveum.midpoint.prism.AbstractFreezable

com.evolveum.midpoint.prism.impl.ItemImpl<V,D>

All Implemented Interfaces:

Freezable, Item<V,D>, Itemable, ItemDefinitionTransformer.TransformableItem, 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>, ItemDefinitionTransformer.TransformableItem

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	incomplete
protected PrismContainerValue<?>	parent
protected @NotNull List<V>	values

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

INDENT_STRING

Method Summary

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 tolerateRawValues, Supplier<String> sourceDescriptionSupplier)
void	assertDefinitions(Supplier<String> sourceDescriptionSupplier)
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<Item<?,?>>	getAllItems(@NotNull ItemPath path)	Returns all items corresponding to the provided path.
@NotNull Collection<PrismValue>	getAllValues(ItemPath path)	Returns all values corresponding to the provided 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()	Currently doing nothing.
void	performFreeze()
protected void	propagateDeepCloneDefinition(@NotNull DeepCloneOperation operation, D clonedDefinition)	TODO description
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)	TODO: Is revive necessary if prism context is static? TODO document (if it's found to be necessary)
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()
void	transformDefinition(ComplexTypeDefinition parent, ItemDefinitionTransformer transformation)
protected void	valueRemoved(V currentValue)

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

incomplete

protected boolean incomplete

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

valueRemoved

protected void valueRemoved(V currentValue)

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()

Description copied from interface: Item

Currently doing nothing.

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)

Description copied from interface: Revivable

TODO: Is revive necessary if prism context is static? TODO document (if it's found to be necessary)

Specified by:

revive in interface Revivable

copyValues

protected void copyValues(CloneStrategy strategy,
                          ItemImpl clone)

propagateDeepCloneDefinition

protected void propagateDeepCloneDefinition(@NotNull
                                            @NotNull DeepCloneOperation operation,
                                            D clonedDefinition)

TODO description

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(Supplier<String> sourceDescriptionSupplier)
                       throws SchemaException

Specified by:

assertDefinitions in interface Item<V extends PrismValue,D extends ItemDefinition>

Throws:

SchemaException

assertDefinitions

public void assertDefinitions(boolean tolerateRawValues,
                              Supplier<String> sourceDescriptionSupplier)
                       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)

Description copied from interface: Item

Returns all values corresponding to the provided path. The path may contain ambiguous segments (e.g. `assignment/targetRef` when there are more assignments). Limitations: . The path can contain only name segments and the "identifier" (`#`) segment - at least for now. No ID segments. . There are no guarantees about duplicate values. They may or may not be present in the returned collections. . The caller should not modify the returned collection in any way. Note to implementors: Please take care about the performance of this method.

Specified by:

getAllValues in interface Item<V extends PrismValue,D extends ItemDefinition>

getAllItems

@NotNull
public @NotNull Collection<Item<?,?>> getAllItems(@NotNull
                                                        @NotNull ItemPath path)

Description copied from interface: Item

Returns all items corresponding to the provided path. This is an analogue to Item.getAllValues(ItemPath). The only difference here is that `#` segment is not allowed, as it does not correspond to an item. (Shouldn't these methods be rather called findAllValues/findAllItems?)

Specified by:

getAllItems 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>

transformDefinition

public void transformDefinition(ComplexTypeDefinition parent,
                                ItemDefinitionTransformer transformation)

Specified by:

transformDefinition in interface ItemDefinitionTransformer.TransformableItem