Package org.ametys.plugins.repository.data.holder.impl

Class DefaultModelAwareDataHolder

java.lang.Object

org.ametys.plugins.repository.data.holder.impl.DefaultModelAwareDataHolder

All Implemented Interfaces:

DataHolder, ModelAwareDataHolder

Direct Known Subclasses:

DefaultIndexableDataHolder, DefaultModifiableModelAwareDataHolder

public class DefaultModelAwareDataHolder
extends Object
implements ModelAwareDataHolder

Default implementation for data holder with model

Field Summary

Fields

Modifier and Type	Field	Description
protected Collection<? extends ModelItemContainer>	_itemContainers	Model containers to use to get information about definitions
protected Optional<? extends ModelAwareDataHolder>	_parent	Parent of the current DataHolder
protected RepositoryData	_repositoryData	Repository data to use to store data in the repository
protected ModelAwareDataHolder	_root	Root DataHolder

Fields inherited from interface org.ametys.plugins.repository.data.holder.ModelAwareDataHolder

ALTERNATIVE_SUFFIX, STATUS_SUFFIX

Constructor Summary

Constructors

Constructor	Description
DefaultModelAwareDataHolder(RepositoryData repositoryData, Collection<? extends ModelItemContainer> itemContainers, Optional<? extends ModelAwareDataHolder> parent, Optional<? extends ModelAwareDataHolder> root)	Creates a default model aware data holder
DefaultModelAwareDataHolder(RepositoryData repositoryData, ModelItemContainer itemContainer)	Creates a default model aware data holder
DefaultModelAwareDataHolder(RepositoryData repositoryData, ModelItemContainer itemContainer, Optional<? extends ModelAwareDataHolder> parent, Optional<? extends ModelAwareDataHolder> root)	Creates a default model aware data holder

Method Summary

Modifier and Type	Method	Description
protected void	checkDefinition(String dataPath, boolean checkStatusAvailable, String errorMsg)	Check definition for data path
protected void	checkDefinition(String dataPath, String errorMsg)	Check definition for data path
protected boolean	checkElementDifferences(ViewElement viewElement, SynchronizableValue value, ValueContext context)	Check if there are differences between the given value and the given view element's value
protected boolean	checkElementDifferencesInRemoveMode(ViewElement viewElement, SynchronizableValue value, ValueContext context)	Check if there are differences between the given value and the given view element's value
protected boolean	checkStatusDifferences(ElementDefinition definition, SynchronizableValue value, SynchronizationContext synchronizationContext, boolean doValuesContainData)	Check if the data's status will have to be changed
protected ModelAwareComposite	createCompositeInstance(RepositoryData compositeRepositoryData, CompositeDefinition compositeDefinition)	Creates an instance of composite
protected Repeater	createRepeaterInstance(RepositoryData repeaterRepositoryData, RepeaterDefinition repeaterDefinition)	Creates an instance of repeater
protected <T extends SynchronizationContext> T	createSynchronizationContextInstance()	Creates an instance of SynchronizationContext
Object	dataToJSON(String dataPath, DataContext context)	Convert the data at the given path into a JSON object
protected Object	dataToJSON(ModelItem modelItem, String dataPath, DataContext context)	Converts the value of the given model item at the given data path to a JSON-serializable object
Map<String,Object>	dataToJSON(ViewItemAccessor viewItemAccessor, DataContext context)	Convert the data in the given view of the current DataHolder
Map<String,Object>	dataToJSONForEdition(ViewItemAccessor viewItemAccessor, DataContext context)	Convert the data in the given view in edition mode in the current DataHolder
Map<String,Object>	dataToMap(ViewItemAccessor viewItemAccessor, DataContext context)	Retrieves data of this DataHolder as a typed-values Map.
void	dataToSAX(ContentHandler contentHandler, String dataPath, DataContext context)	Generates SAX events for the data at the given data path in the current DataHolder Do not generate any event if there is no values at the given path
protected void	dataToSAX(ContentHandler contentHandler, ModelItem modelItem, String dataPath, DataContext context)	Generates SAX events for the given model item at the given data path
void	dataToSAX(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context)	Generates SAX events for the data in the given view in the current DataHolder
void	dataToSAXForEdition(ContentHandler contentHandler, ViewItemAccessor viewItemAccessor, DataContext context)	Generates SAX events for the data in the given view in edition mode in the current DataHolder
protected boolean	doesHaveDifferences(ViewItemAccessor viewItemAccessor, Map<String,Object> values, SynchronizationContext context)	Check if there are differences between the given values and the current ones
protected Collection<ModelItem>	doGetDifferences(ViewItemAccessor viewItemAccessor, Map<String,Object> values, SynchronizationContext context)	Get the collection of model items where there are differences between the given values and the current ones
protected void	ensureNonNullItemContainers()	Ensures that no null item container has been given to constructor
ModelAwareComposite	getComposite(String compositePath)	Retrieves the composite at the given path
protected ModelAwareComposite	getComposite(String name, CompositeDefinition compositeDefinition)	Retrieves the composite with the given name
protected Class	getCompositeClass()	Retrieves the class of the managed composites
protected ModelAwareComposite	getCompositeFromValue(Object value, String compositePath)	Retrieves the composite from the given value
Collection<String>	getDataNames()	Retrieves the names of data contained by this data holder Retrieves only the data at first level, does not check composite data
Collection<ModelItem>	getDifferences(ViewItemAccessor viewItemAccessor, Map<String,Object> values)	Get the collection of model items where there are differences between the given values and the current ones
Collection<ModelItem>	getDifferences(ViewItemAccessor viewItemAccessor, Map<String,Object> values, SynchronizationContext context)	Get the collection of model items where there are differences between the given values and the current ones
protected Collection<ModelItem>	getDifferencesInGroup(ModelViewItemGroup modelViewItemGroup, Map<String,Object> values, SynchronizationContext synchronizationContext)	Get the collection of model items where there are differences between the given values and the given group's ones
protected <T> T	getElementValue(ElementDefinition definition, String dataName)	Retrieves the value of the given element definition
ModelAwareComposite	getExternalComposite(String compositePath)	Retrieves the external composite at the given path
Repeater	getExternalRepeater(String repeaterPath)	Retrieves the external repeater at the given path
<T> T	getExternalValue(String dataPath)	Retrieves the external value of the data at the given path
protected String	getFinalDataName(String dataName, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)	Retrieves the name of the data according to the given status
protected <T> T	getGroupValue(ModelItem modelItem, String dataName)	Retrieves the value of the given group model item (composite or repeater)
ModelAwareComposite	getLocalComposite(String compositePath)	Retrieves the local composite at the given path
Repeater	getLocalRepeater(String repeaterPath)	Retrieves the local repeater at the given path
<T> T	getLocalValue(String dataPath)	Retrieves the local value of the data at the given path
protected Class	getManagedClass(ModelAwareDataHolder dataHolder, String dataPath)	Retrieves the managed class for the model item at the given data path in the given data holder
Collection<? extends ModelItemContainer>	getModel()	Retrieves the data holder's model
protected <T> T	getMultipleValues(String dataPath)	Retrieves the aggregated values when the first segment of the data path refers to a multiple data (repeater or multiple value)
Optional<? extends ModelAwareDataHolder>	getParentDataHolder()	Retrieves the optional parent of the current DataHolder There can be no parent if the current DataHolder is the root
Repeater	getRepeater(String repeaterPath)	Retrieves the repeater at the given path
protected Repeater	getRepeater(String name, RepeaterDefinition repeaterDefinition)	Retrieves the repeater with the given name
protected Class	getRepeaterClass()	Retrieves the class of the managed repeaters
protected Class	getRepeaterEntryClass()	Retrieves the class of the managed repeater entries
protected Repeater	getRepeaterFromValue(Object value, String repeaterPath)	Retrieves the repeater from the given value
RepositoryData	getRepositoryData()	Retrieves the repository data used by this DataHolder
ModelAwareDataHolder	getRootDataHolder()	Retrieves the DataHolder that is the root of the current one
ExternalizableDataProvider.ExternalizableDataStatus	getStatus(String dataPath)	Retrieves the status of the externalizable data at the given path Warning: This method won't check that your data is externalizable.
<T> T	getValue(String dataPath)	Retrieves the value of the data at the given path
protected <T> T	getValue(String dataPath, boolean allowMultiValuedPathSegments, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)	Retrieves the value at the given data path
<T> T	getValueOrDefault(String dataPath)	Retrieves the value of the data at the given path if exists and is not empty, or the default value from the model
<T> T	getValueOrDefault(String dataPath, T defaultValue)	Retrieves the value of the data at the given path if exists and is not empty, or the given default value
<T> T	getValueWithMultiValuedPathSegments(String dataPath)	Retrieves the value of the data at the given path, allowing multi-valued segments in the path (not necessarily at the last segment) if there is no indicated entry for a repeater, the values of all the entries are retrieved if there are multiple values, all data are retrieved in one array
protected boolean	hasDefaultValue(ModelItem modelItem)	Check if the given model item has a default value
boolean	hasDifferences(ViewItemAccessor viewItemAccessor, Map<String,Object> values)	Check if there are differences between the given values and the current ones
boolean	hasDifferences(ViewItemAccessor viewItemAccessor, Map<String,Object> values, SynchronizationContext context)	Check if there are differences between the given values and the current ones
protected boolean	hasDifferencesInElement(ViewElement viewElement, Map<String,Object> values, SynchronizationContext synchronizationContext)	Check if there are differences between the given values and the given element's ones
protected boolean	hasDifferencesInGroup(ModelViewItemGroup modelViewItemGroup, Map<String,Object> values, SynchronizationContext synchronizationContext)	Check if there are differences between the given values and the given group's ones
boolean	hasExternalValue(String dataPath)	Checks if there is a non empty external value for the data at the given path
boolean	hasExternalValueOrEmpty(String dataPath)	Checks if there is an external value for the data at the given path
boolean	hasLocalValue(String dataPath)	Checks if there is a non empty local value for the data at the given path
boolean	hasLocalValueOrEmpty(String dataPath)	Checks if there is a local value for the data at the given path
boolean	hasValue(String dataPath)	Checks if there is a non empty value for the data at the given path
protected boolean	hasValue(String dataPath, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)	Checks if there is a non-empty value for the given data path with the given externalizable status
protected boolean	hasValueForName(String dataName, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)	Checks if there is a non-empty value for the given simple data name (no path separator) with the given externalizable status
boolean	hasValueOrEmpty(String dataPath)	Checks if there is a value, even empty, for the data at the given path
protected boolean	hasValueOrEmpty(String dataPath, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)	Checks if there is a value (possibly empty) for the given data path with the given externalizable status
protected boolean	hasValueOrEmptyForName(String dataName, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)	Checks if there is a value (possibly empty) for the given simple data name (no path separator) with the given externalizable status

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.ametys.plugins.repository.data.holder.DataHolder

copyTo, copyTo, dataToJSON, dataToSAX

Methods inherited from interface org.ametys.plugins.repository.data.holder.ModelAwareDataHolder

dataToJSON, dataToJSON, dataToJSON, dataToMap, dataToMap, dataToMap, dataToSAX, dataToSAX, dataToSAX, getDefinition, getDifferences, getDifferences, getModelItemTypeExtensionPoint, getType, getValueOfType, getValueOfTypeOrDefault, hasDefinition, hasDifferences, hasDifferences, hasValue, isMultiple, isMultiple

Field Details

_repositoryData

protected RepositoryData _repositoryData

Repository data to use to store data in the repository

_parent

protected Optional<? extends ModelAwareDataHolder> _parent

Parent of the current DataHolder

_root

protected ModelAwareDataHolder _root

Root DataHolder

_itemContainers

protected Collection<? extends ModelItemContainer> _itemContainers

Model containers to use to get information about definitions

Constructor Details

DefaultModelAwareDataHolder

public DefaultModelAwareDataHolder(RepositoryData repositoryData,
 ModelItemContainer itemContainer)

Creates a default model aware data holder

Parameters:

repositoryData - the repository data to use

itemContainer - the model container to use to get information about definitions. Must match the given repository data. A repository data can have several item containers. For example, a content can have several content types.

DefaultModelAwareDataHolder

public DefaultModelAwareDataHolder(RepositoryData repositoryData,
 ModelItemContainer itemContainer,
 Optional<? extends ModelAwareDataHolder> parent,
 Optional<? extends ModelAwareDataHolder> root)

Creates a default model aware data holder

Parameters:

repositoryData - the repository data to use

itemContainer - the model container to use to get information about definitions. Must match the given repository data. A repository data can have several item containers. For example, a content can have several content types.

parent - the optional parent of the created DataHolder, empty if the created DataHolder is the root DataHolder

root - the root DataHolder

DefaultModelAwareDataHolder

public DefaultModelAwareDataHolder(RepositoryData repositoryData,
 Collection<? extends ModelItemContainer> itemContainers,
 Optional<? extends ModelAwareDataHolder> parent,
 Optional<? extends ModelAwareDataHolder> root)

Creates a default model aware data holder

Parameters:

repositoryData - the repository data to use

itemContainers - the model containers to use to get information about definitions. Must match the given repository data. A repository data can have several item containers. For example, a content can have several content types.

parent - the parent of the created DataHolder, empty if the created DataHolder is the root DataHolder

root - the root DataHolder

Method Details

ensureNonNullItemContainers

protected void ensureNonNullItemContainers()
                                    throws NullPointerException

Ensures that no null item container has been given to constructor

Throws:

NullPointerException - if a there is a null item container

getComposite

public ModelAwareComposite getComposite(String compositePath)
                                 throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: DataHolder

Retrieves the composite at the given path

Specified by:

getComposite in interface DataHolder

Specified by:

getComposite in interface ModelAwareDataHolder

Parameters:

compositePath - path of the composite to retrieve

Returns:

the composite or null if not exists or is empty

Throws:

IllegalArgumentException - if the given composite path is null or empty

BadItemTypeException - if the stored value at the given path is not a composite

UndefinedItemPathException - if the data holder has a model and the given composite path is not defined by this model

BadDataPathCardinalityException - if the data holder has a model and the definition of a part of the data path is multiple. Only the last part can be multiple

getLocalComposite

public ModelAwareComposite getLocalComposite(String compositePath)
                                      throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the local composite at the given path

Specified by:

getLocalComposite in interface ModelAwareDataHolder

Parameters:

compositePath - path of the externalizable composite to retrieve

Returns:

the composite or null if not exists or is empty

Throws:

IllegalArgumentException - if the given composite path is null or empty

BadItemTypeException - if the stored value at the given path is not a composite

UndefinedItemPathException - if the given composite path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getExternalComposite

public ModelAwareComposite getExternalComposite(String compositePath)
                                         throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the external composite at the given path

Specified by:

getExternalComposite in interface ModelAwareDataHolder

Parameters:

compositePath - path of the externalizable composite to retrieve

Returns:

the composite or null if not exists or is empty

Throws:

IllegalArgumentException - if the given composite path is null or empty

BadItemTypeException - if the stored value at the given path is not a composite

UndefinedItemPathException - if the given composite path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getCompositeFromValue

protected ModelAwareComposite getCompositeFromValue(Object value,
 String compositePath)
                                             throws BadItemTypeException

Retrieves the composite from the given value

Parameters:

value - the given value as a composite

compositePath - the path of the composite

Returns:

the composite, or null if the value is null

Throws:

BadItemTypeException - if the value is not a Composite

getRepeater

public Repeater getRepeater(String repeaterPath)
                     throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the repeater at the given path

Specified by:

getRepeater in interface ModelAwareDataHolder

Parameters:

repeaterPath - path of the repeater to retrieve

Returns:

the repeater or null if not exists or is empty

Throws:

IllegalArgumentException - if the given repeater path is null or empty

BadItemTypeException - if the stored value at the given path is not a repeater

UndefinedItemPathException - if the given repeater path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getLocalRepeater

public Repeater getLocalRepeater(String repeaterPath)
                          throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the local repeater at the given path

Specified by:

getLocalRepeater in interface ModelAwareDataHolder

Parameters:

repeaterPath - path of the externalizable repeater to retrieve

Returns:

the repeater or null if not exists or is empty

Throws:

IllegalArgumentException - if the given repeater path is null or empty

BadItemTypeException - if the stored value at the given path is not a repeater

UndefinedItemPathException - if the given repeater path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getExternalRepeater

public Repeater getExternalRepeater(String repeaterPath)
                             throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the external repeater at the given path

Specified by:

getExternalRepeater in interface ModelAwareDataHolder

Parameters:

repeaterPath - path of the externalizable repeater to retrieve

Returns:

the repeater or null if not exists or is empty

Throws:

IllegalArgumentException - if the given repeater path is null or empty

BadItemTypeException - if the stored value at the given path is not a repeater

UndefinedItemPathException - if the given repeater path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getRepeaterFromValue

protected Repeater getRepeaterFromValue(Object value,
 String repeaterPath)
                                 throws BadItemTypeException

Retrieves the repeater from the given value

Parameters:

value - the given value as a repeater

repeaterPath - the path of the repeater

Returns:

the repeater, or null if the value is null

Throws:

BadItemTypeException - if the value is not a Repeater

hasValue

public boolean hasValue(String dataPath)
                 throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: DataHolder

Checks if there is a non empty value for the data at the given path

Specified by:

hasValue in interface DataHolder

Parameters:

dataPath - path of the data

Returns:

true if there is a non empty value for the data. If the data holder has a model and the data at the given path is defined by the model and the type of this value matches the type of the definition. false otherwise

Throws:

IllegalArgumentException - if the given data path is null or empty

BadDataPathCardinalityException - if the data holder has a model and the definition of a part of the data path is multiple. Only the last part can be multiple

hasLocalValue

public boolean hasLocalValue(String dataPath)
                      throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Checks if there is a non empty local value for the data at the given path

Specified by:

hasLocalValue in interface ModelAwareDataHolder

Parameters:

dataPath - path of the externalizable data

Returns:

true if the data at the given path is defined by the model, if there is a non empty local value for the data and if the type of this value matches the type of the definition. false otherwise

Throws:

IllegalArgumentException - if the given data path is null or empty

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

hasExternalValue

public boolean hasExternalValue(String dataPath)
                         throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Checks if there is a non empty external value for the data at the given path

Specified by:

hasExternalValue in interface ModelAwareDataHolder

Parameters:

dataPath - path of the externalizable data

Returns:

true if the data at the given path is defined by the model, if there is a non empty external value for the data and if the type of this value matches the type of the definition. false otherwise

Throws:

IllegalArgumentException - if the given data path is null or empty

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

hasValue

protected boolean hasValue(String dataPath,
 Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)
                    throws IllegalArgumentException,
BadDataPathCardinalityException

Checks if there is a non-empty value for the given data path with the given externalizable status

Parameters:

dataPath - the path of the data

status - the optional externalizable status to filter on, or empty to check the current value

Returns:

true if there is a non-empty value at the given path, false otherwise

Throws:

IllegalArgumentException - if the data path is empty

BadDataPathCardinalityException - if a segment of the data path refers to a multiple data

hasValueForName

protected boolean hasValueForName(String dataName,
 Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)

Checks if there is a non-empty value for the given simple data name (no path separator) with the given externalizable status

Parameters:

dataName - the name of the data (no path separator)

status - the optional externalizable status to filter on, or empty to check the current value

Returns:

true if there is a non-empty value for the given name, false otherwise

hasValueOrEmpty

public boolean hasValueOrEmpty(String dataPath)
                        throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: DataHolder

Checks if there is a value, even empty, for the data at the given path

Specified by:

hasValueOrEmpty in interface DataHolder

Parameters:

dataPath - path of the data

Returns:

true if there is value, even empty, for the data. If the data holder has a model and the data at the given path is defined by the model and the type of this value matches the type of the definition. false otherwise

Throws:

IllegalArgumentException - if the given data path is null or empty

BadDataPathCardinalityException - if the data holder has a model and the definition of a part of the data path is multiple. Only the last part can be multiple

hasLocalValueOrEmpty

public boolean hasLocalValueOrEmpty(String dataPath)
                             throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Checks if there is a local value for the data at the given path

Specified by:

hasLocalValueOrEmpty in interface ModelAwareDataHolder

Parameters:

dataPath - path of the externalizable data

Returns:

true if the data at the given path is defined by the model, if there is a local value for the data, even empty, and if the type of this value matches the type of the definition. false otherwise

Throws:

IllegalArgumentException - if the given data path is null or empty

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

hasExternalValueOrEmpty

public boolean hasExternalValueOrEmpty(String dataPath)
                                throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Checks if there is an external value for the data at the given path

Specified by:

hasExternalValueOrEmpty in interface ModelAwareDataHolder

Parameters:

dataPath - path of the externalizable data

Returns:

true if the data at the given path is defined by the model, if there is an external value for the data, even empty, and if the type of this value matches the type of the definition. false otherwise

Throws:

IllegalArgumentException - if the given data path is null or empty

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

hasValueOrEmpty

protected boolean hasValueOrEmpty(String dataPath,
 Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)
                           throws IllegalArgumentException,
BadDataPathCardinalityException

Checks if there is a value (possibly empty) for the given data path with the given externalizable status

Parameters:

dataPath - the path of the data

status - the optional externalizable status to filter on, or empty to check the current value

Returns:

true if there is a value at the given path (even empty), false otherwise

Throws:

IllegalArgumentException - if the data path is empty

BadDataPathCardinalityException - if a segment of the data path refers to a multiple data

hasValueOrEmptyForName

protected boolean hasValueOrEmptyForName(String dataName,
 Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)

Checks if there is a value (possibly empty) for the given simple data name (no path separator) with the given externalizable status

Parameters:

dataName - the name of the data (no path separator)

status - the optional externalizable status to filter on, or empty to check the current value

Returns:

true if there is a value for the given name (even empty), false otherwise

getValue

public <T> T getValue(String dataPath)
               throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: DataHolder

Retrieves the value of the data at the given path

Specified by:

getValue in interface DataHolder

Type Parameters:

T - type of the value to retrieve. If the data holder has a model, the type of the value is defined by this model. Otherwise, the type of the value will be deduced from the stored data. In some cases, the type can be wrong. For example, it is impossible to know if a stored date is a date or a date time

Parameters:

dataPath - path of the data

Returns:

the value of the data or null if not exists or is empty. A typed array is returned for multiple empty data, and an empty string is returned for single empty string data

Throws:

IllegalArgumentException - if the given data path is null or empty

BadItemTypeException - if the data holder has a model and the type defined by the model doesn't match the type of the stored value, or if value at the sub data path of the given one is not a composite

UndefinedItemPathException - if the data holder has a model and the given data path is not defined by this model

BadDataPathCardinalityException - if the data holder has a model and the definition of a part of the data path is multiple. Only the last part can be multiple

getLocalValue

public <T> T getLocalValue(String dataPath)
                    throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the local value of the data at the given path

Specified by:

getLocalValue in interface ModelAwareDataHolder

Type Parameters:

T - type of the value to retrieve. The type of the value is defined by the model.

Parameters:

dataPath - path of the externalizable data

Returns:

the local value of the data or null if not exists or is empty. A typed array is returned for multiple empty data, and an empty string is returned for single empty string data

Throws:

IllegalArgumentException - if the given data path is null or empty

BadItemTypeException - if the type defined by the model doesn't match the type of the stored value

UndefinedItemPathException - if the given data path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getExternalValue

public <T> T getExternalValue(String dataPath)
                       throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the external value of the data at the given path

Specified by:

getExternalValue in interface ModelAwareDataHolder

Type Parameters:

T - type of the value to retrieve. The type of the value is defined by the model.

Parameters:

dataPath - path of the externalizable data

Returns:

the external value of the data or null if not exists or is empty. A typed array is returned for multiple empty data, and an empty string is returned for single empty string data

Throws:

IllegalArgumentException - if the given data path is null or empty

BadItemTypeException - if the type defined by the model doesn't match the type of the stored value

UndefinedItemPathException - if the given data path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getValueWithMultiValuedPathSegments

public <T> T getValueWithMultiValuedPathSegments(String dataPath)
                                          throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the value of the data at the given path, allowing multi-valued segments in the path (not necessarily at the last segment) if there is no indicated entry for a repeater, the values of all the entries are retrieved if there are multiple values, all data are retrieved in one array

Specified by:

getValueWithMultiValuedPathSegments in interface ModelAwareDataHolder

Type Parameters:

T - type of the value to retrieve

Parameters:

dataPath - path of the data

Returns:

the value of the data

Throws:

IllegalArgumentException - if the given data path is null or empty

BadItemTypeException - if the type defined by the model doesn't match the type of the stored value

UndefinedItemPathException - if the given data path is not defined by the model

BadDataPathCardinalityException - if the managesMultiples boolean is false and the definition of a part of the data path is multiple. Only the last part can be multiple

getValue

protected <T> T getValue(String dataPath,
 boolean allowMultiValuedPathSegments,
 Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)
                  throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Retrieves the value at the given data path

Type Parameters:

T - the expected type of the value

Parameters:

dataPath - the path of the data

allowMultiValuedPathSegments - true to allow multiple-valued intermediate path segments and aggregate their values

status - the optional externalizable status to filter on, or empty to retrieve the current value

Returns:

the value at the given path, or null if there is no value

Throws:

IllegalArgumentException - if the data path is empty

BadItemTypeException - if the type stored in the repository does not match the expected type

UndefinedItemPathException - if the path does not match any definition

BadDataPathCardinalityException - if a non-terminal segment of the data path refers to a multiple data

getStatus

public ExternalizableDataProvider.ExternalizableDataStatus getStatus(String dataPath)
                                                              throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the status of the externalizable data at the given path Warning: This method won't check that your data is externalizable. But there is no sense to call it with a non externalizable data

Specified by:

getStatus in interface ModelAwareDataHolder

Parameters:

dataPath - path of the externalizable data

Returns:

the status of the externalizable data at the given path

Throws:

IllegalArgumentException - if the given data path is null or empty

BadItemTypeException - if the given data path is composed of an item with type defined by the model that doesn't match the type of the stored value

UndefinedItemPathException - if the given data path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

getElementValue

protected <T> T getElementValue(ElementDefinition definition,
 String dataName)
                         throws BadItemTypeException

Retrieves the value of the given element definition

Type Parameters:

T - the expected type of the value

Parameters:

definition - the definition of the element

dataName - the final name (possibly altered with a status suffix) to use to read the repository data

Returns:

the value read from the repository, possibly coerced from single to multiple or vice versa

Throws:

BadItemTypeException - if the type defined by the model doesn't match the type of the stored value

getGroupValue

protected <T> T getGroupValue(ModelItem modelItem,
 String dataName)
                       throws BadItemTypeException

Retrieves the value of the given group model item (composite or repeater)

Type Parameters:

T - the expected type of the value

Parameters:

modelItem - the model item (must be a CompositeDefinition or a RepeaterDefinition)

dataName - the name of the data to retrieve

Returns:

the composite, repeater or repeater entry, or null if it does not exist

Throws:

BadItemTypeException - if the type defined by the model doesn't match the type of the stored value

getComposite

protected ModelAwareComposite getComposite(String name,
 CompositeDefinition compositeDefinition)
                                    throws BadItemTypeException

Retrieves the composite with the given name

Parameters:

name - name of the composite to retrieve

compositeDefinition - the definition of the composite to retrieve

Returns:

the composite

Throws:

BadItemTypeException - if the value stored in the repository with the given name is not a composite

createCompositeInstance

protected ModelAwareComposite createCompositeInstance(RepositoryData compositeRepositoryData,
 CompositeDefinition compositeDefinition)

Creates an instance of composite

Parameters:

compositeRepositoryData - the repository data of the composite to create

compositeDefinition - the definition of the composite to create

Returns:

the created composite instance

getRepeater

protected Repeater getRepeater(String name,
 RepeaterDefinition repeaterDefinition)
                        throws BadItemTypeException

Retrieves the repeater with the given name

Parameters:

name - name of the repeater to retrieve

repeaterDefinition - the definition of the repeater to retrieve

Returns:

the repeater

Throws:

BadItemTypeException - if the value stored in the repository with the given name is not a repeater

createRepeaterInstance

protected Repeater createRepeaterInstance(RepositoryData repeaterRepositoryData,
 RepeaterDefinition repeaterDefinition)

Creates an instance of repeater

Parameters:

repeaterRepositoryData - the repository data of the repeater to create

repeaterDefinition - the definition of the repeater to create

Returns:

the created repeater instance

getMultipleValues

protected <T> T getMultipleValues(String dataPath)

Retrieves the aggregated values when the first segment of the data path refers to a multiple data (repeater or multiple value)

Type Parameters:

T - the expected type of the aggregated values

Parameters:

dataPath - the full data path whose first segment is multiple-valued

Returns:

an array aggregating the values obtained from each entry of the multiple segment

getManagedClass

protected Class getManagedClass(ModelAwareDataHolder dataHolder,
 String dataPath)

Retrieves the managed class for the model item at the given data path in the given data holder

Parameters:

dataHolder - the data holder owning the data

dataPath - the path of the data

Returns:

the managed class (element type, composite, repeater or repeater entry class depending on the model item)

getRepeaterEntryClass

protected Class getRepeaterEntryClass()

Retrieves the class of the managed repeater entries

Returns:

the class of the managed repeater entries

getRepeaterClass

protected Class getRepeaterClass()

Retrieves the class of the managed repeaters

Returns:

the class of the managed repeaters

getCompositeClass

protected Class getCompositeClass()

Retrieves the class of the managed composites

Returns:

the class of the managed composites

getValueOrDefault

public <T> T getValueOrDefault(String dataPath)
                        throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

Retrieves the value of the data at the given path if exists and is not empty, or the default value from the model

Specified by:

getValueOrDefault in interface ModelAwareDataHolder

Type Parameters:

T - type of the value to retrieve. The type of the value is defined by the model.

Parameters:

dataPath - path of the data

Returns:

the value of the data, or the default value from the model if the value does not exist or is empty

Throws:

IllegalArgumentException - if the given data path is null or empty

BadItemTypeException - if the type defined by the model doesn't match the type of the stored value

UndefinedItemPathException - if the given data path is not defined by the model

BadDataPathCardinalityException - if the definition of a part of the data path is multiple. Only the last part can be multiple

hasDefaultValue

protected boolean hasDefaultValue(ModelItem modelItem)

Check if the given model item has a default value

Parameters:

modelItem - the model item to check

Returns:

true if the model item has a default value, false otherwise

getValueOrDefault

public <T> T getValueOrDefault(String dataPath,
 T defaultValue)
                        throws IllegalArgumentException,
BadItemTypeException,
UndefinedItemPathException,
BadDataPathCardinalityException

Description copied from interface: DataHolder

Retrieves the value of the data at the given path if exists and is not empty, or the given default value

Specified by:

getValueOrDefault in interface DataHolder

Type Parameters:

T - type of the value to retrieve. If the data holder has a model, the type of the value is defined by this model. Otherwise, the type of the value will be deduced from the stored data. In some cases, the type can be wrong. For example, it is impossible to know if a stored date is a date or a date time

Parameters:

dataPath - path of the data

defaultValue - default value

Returns:

the value of the data, or the given default value if the value does not exist or is empty

Throws:

IllegalArgumentException - if the given data path is null or empty

BadItemTypeException - if value at the sub data path of the given one is not a composite

UndefinedItemPathException - if the data holder has a model and the given data path is not defined by this model

BadDataPathCardinalityException - if the data holder has a model and the definition of a part of the data path is multiple. Only the last part can be multiple

getFinalDataName

protected String getFinalDataName(String dataName,
 Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)

Retrieves the name of the data according to the given status

Parameters:

dataName - the name of the data

status - the status

Returns:

the final name of the data

getModel

public Collection<? extends ModelItemContainer> getModel()

Description copied from interface: ModelAwareDataHolder

Retrieves the data holder's model

Specified by:

getModel in interface ModelAwareDataHolder

Returns:

the data holder's model

getDataNames

public Collection<String> getDataNames()

Description copied from interface: ModelAwareDataHolder

Retrieves the names of data contained by this data holder Retrieves only the data at first level, does not check composite data

Specified by:

getDataNames in interface DataHolder

Specified by:

getDataNames in interface ModelAwareDataHolder

Returns:

the names of the data contained by this data holder and that are defined by the model

dataToSAX

public void dataToSAX(ContentHandler contentHandler,
 String dataPath,
 DataContext context)
               throws SAXException,
BadItemTypeException,
UndefinedItemPathException

Description copied from interface: DataHolder

Generates SAX events for the data at the given data path in the current DataHolder Do not generate any event if there is no values at the given path

Specified by:

dataToSAX in interface DataHolder

Parameters:

contentHandler - the ContentHandler that will receive the SAX events

dataPath - the path of the data to SAX

context - The context of the data to SAX

Throws:

SAXException - if an error occurs during the SAX events generation

BadItemTypeException - if the saxed value's type does not matches the stored data

UndefinedItemPathException - if the data holder has a model and the given data path is not defined by this model

dataToSAX

protected void dataToSAX(ContentHandler contentHandler,
 ModelItem modelItem,
 String dataPath,
 DataContext context)
                  throws SAXException,
BadItemTypeException

Generates SAX events for the given model item at the given data path

Parameters:

contentHandler - the content handler to use to generate SAX events

modelItem - the model item describing the data

dataPath - the path of the data

context - the context of the data

Throws:

SAXException - if an error occurs while generating SAX events

BadItemTypeException - if the saxed value's type does not matches the stored data

dataToSAX

public void dataToSAX(ContentHandler contentHandler,
 ViewItemAccessor viewItemAccessor,
 DataContext context)
               throws SAXException,
BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Generates SAX events for the data in the given view in the current DataHolder

Specified by:

dataToSAX in interface ModelAwareDataHolder

Parameters:

contentHandler - the ContentHandler that will receive the SAX events

viewItemAccessor - the ViewItemAccessor referencing the items for which generate SAX events

context - The context of the data to SAX

Throws:

SAXException - if an error occurs during the SAX events generation

BadItemTypeException - if the saxed value's type does not matches the stored data

dataToSAXForEdition

public void dataToSAXForEdition(ContentHandler contentHandler,
 ViewItemAccessor viewItemAccessor,
 DataContext context)
                         throws SAXException,
BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Generates SAX events for the data in the given view in edition mode in the current DataHolder

Specified by:

dataToSAXForEdition in interface ModelAwareDataHolder

Parameters:

contentHandler - the ContentHandler that will receive the SAX events

viewItemAccessor - the ViewItemAccessor referencing the items for which generate SAX events

context - The context of the data to SAX

Throws:

SAXException - if an error occurs during the SAX events generation

BadItemTypeException - if the saxed value's type does not matches the stored data

dataToJSON

public Object dataToJSON(String dataPath,
 DataContext context)
                  throws BadItemTypeException,
UndefinedItemPathException

Description copied from interface: DataHolder

Convert the data at the given path into a JSON object

Specified by:

dataToJSON in interface DataHolder

Parameters:

dataPath - the path of the data to convert

context - The context of the data to convert

Returns:

The value as JSON

Throws:

BadItemTypeException - if the value's type does not matches the stored data

UndefinedItemPathException - if the data holder has a model and the given data path is not defined by this model

dataToJSON

protected Object dataToJSON(ModelItem modelItem,
 String dataPath,
 DataContext context)
                     throws BadItemTypeException

Converts the value of the given model item at the given data path to a JSON-serializable object

Parameters:

modelItem - the model item describing the data

dataPath - the path of the data

context - the context of the data

Returns:

the JSON-serializable representation of the value, or null if there is no value

Throws:

BadItemTypeException - if the value's type does not matches the stored data

dataToJSON

public Map<String,Object> dataToJSON(ViewItemAccessor viewItemAccessor,
 DataContext context)
                              throws BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Convert the data in the given view of the current DataHolder

Specified by:

dataToJSON in interface ModelAwareDataHolder

Parameters:

viewItemAccessor - the ViewItemAccessor referencing the items to convert

context - The context of the data to convert

Returns:

The data of the given view as JSON

Throws:

BadItemTypeException - if the value's type does not matches the stored data

dataToJSONForEdition

public Map<String,Object> dataToJSONForEdition(ViewItemAccessor viewItemAccessor,
 DataContext context)
                                        throws BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Convert the data in the given view in edition mode in the current DataHolder

Specified by:

dataToJSONForEdition in interface ModelAwareDataHolder

Parameters:

viewItemAccessor - the ViewItemAccessor referencing the items to convert

context - The context of the data to convert

Returns:

The data of the given view as JSON

Throws:

BadItemTypeException - if the value's type does not matches the stored data

dataToMap

public Map<String,Object> dataToMap(ViewItemAccessor viewItemAccessor,
 DataContext context)
                             throws BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Retrieves data of this DataHolder as a typed-values Map.

Specified by:

dataToMap in interface ModelAwareDataHolder

Parameters:

viewItemAccessor - the ViewItemAccessor referencing the items to include in the resulting Map

context - The context of the data

Returns:

a Map containing all data.

Throws:

BadItemTypeException - if the value's type does not matches the stored data

hasDifferences

public boolean hasDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values)
                       throws BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Check if there are differences between the given values and the current ones

Specified by:

hasDifferences in interface ModelAwareDataHolder

Parameters:

viewItemAccessor - The ViewItemAccessor for all items to check

values - the values to check

Returns:

true if there are differences, false otherwise

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

hasDifferences

public boolean hasDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values,
 SynchronizationContext context)
                       throws BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Check if there are differences between the given values and the current ones

Specified by:

hasDifferences in interface ModelAwareDataHolder

Parameters:

viewItemAccessor - The ViewItemAccessor for all items to check

values - the values to check

context - the context of the synchronization

Returns:

true if there are differences, false otherwise

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

doesHaveDifferences

protected boolean doesHaveDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values,
 SynchronizationContext context)
                               throws BadItemTypeException

Check if there are differences between the given values and the current ones

Parameters:

viewItemAccessor - The ViewItemAccessor for all items to check

values - the values to check

context - the context of the synchronization

Returns:

true if there are differences, false otherwise

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

getDifferences

public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values)
                                     throws BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Get the collection of model items where there are differences between the given values and the current ones

Specified by:

getDifferences in interface ModelAwareDataHolder

Parameters:

viewItemAccessor - The ViewItemAccessor for all items to check

values - the values to check

Returns:

a collection of model items with differences

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

getDifferences

public Collection<ModelItem> getDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values,
 SynchronizationContext context)
                                     throws BadItemTypeException

Description copied from interface: ModelAwareDataHolder

Get the collection of model items where there are differences between the given values and the current ones

Specified by:

getDifferences in interface ModelAwareDataHolder

Parameters:

viewItemAccessor - The ViewItemAccessor for all items to check

values - the values to check

context - the context of the synchronization

Returns:

a collection of model items with differences

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

doGetDifferences

protected Collection<ModelItem> doGetDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values,
 SynchronizationContext context)
                                          throws BadItemTypeException

Get the collection of model items where there are differences between the given values and the current ones

Parameters:

viewItemAccessor - The ViewItemAccessor for all items to check

values - the values to check

context - the context of the synchronization

Returns:

a collection of model items with differences

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

hasDifferencesInGroup

protected boolean hasDifferencesInGroup(ModelViewItemGroup modelViewItemGroup,
 Map<String,Object> values,
 SynchronizationContext synchronizationContext)
                                 throws BadItemTypeException

Check if there are differences between the given values and the given group's ones

Parameters:

modelViewItemGroup - the group

values - the values to check

synchronizationContext - the context of the synchronization

Returns:

true if there are differences, false otherwise

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

getDifferencesInGroup

protected Collection<ModelItem> getDifferencesInGroup(ModelViewItemGroup modelViewItemGroup,
 Map<String,Object> values,
 SynchronizationContext synchronizationContext)
                                               throws BadItemTypeException

Get the collection of model items where there are differences between the given values and the given group's ones

Parameters:

modelViewItemGroup - the group

values - the values to check

synchronizationContext - the context of the synchronization

Returns:

a collection of model items with differences

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

hasDifferencesInElement

protected boolean hasDifferencesInElement(ViewElement viewElement,
 Map<String,Object> values,
 SynchronizationContext synchronizationContext)
                                   throws BadItemTypeException

Check if there are differences between the given values and the given element's ones

Parameters:

viewElement - the element

values - the values to check

synchronizationContext - the context of the synchronization

Returns:

true if there are differences, false otherwise

Throws:

BadItemTypeException - if the type defined by the model of one of the Map's key doesn't match the corresponding value

checkElementDifferences

protected boolean checkElementDifferences(ViewElement viewElement,
 SynchronizableValue value,
 ValueContext context)
                                   throws BadItemTypeException

Check if there are differences between the given value and the given view element's value

Parameters:

viewElement - the element

value - the value to check

context - context of the data to check

Returns:

true if there are differences, false otherwise

Throws:

BadItemTypeException - if the type defined by the model doesn't match the given value to set

checkElementDifferencesInRemoveMode

protected boolean checkElementDifferencesInRemoveMode(ViewElement viewElement,
 SynchronizableValue value,
 ValueContext context)
                                               throws BadItemTypeException

Check if there are differences between the given value and the given view element's value

Parameters:

viewElement - the element

value - the value to check

context - context of the data to check

Returns:

true if there are differences, false otherwise

Throws:

BadItemTypeException - if the type defined by the model doesn't match the given value to set

checkStatusDifferences

protected boolean checkStatusDifferences(ElementDefinition definition,
 SynchronizableValue value,
 SynchronizationContext synchronizationContext,
 boolean doValuesContainData)

Check if the data's status will have to be changed

Parameters:

definition - definition of the data

value - the value

synchronizationContext - the context of the synchronization

doValuesContainData - true if the values contain the data, false otherwise

Returns:

true if the status has changed, false otherwise

createSynchronizationContextInstance

protected <T extends SynchronizationContext> T createSynchronizationContextInstance()

Creates an instance of SynchronizationContext

Type Parameters:

T - the type of the SynchronizationContext

Returns:

the created SynchronizationContext

getRepositoryData

public RepositoryData getRepositoryData()

Description copied from interface: DataHolder

Retrieves the repository data used by this DataHolder

Specified by:

getRepositoryData in interface DataHolder

Returns:

the repository data used by this DataHolder

getParentDataHolder

public Optional<? extends ModelAwareDataHolder> getParentDataHolder()

Description copied from interface: DataHolder

Retrieves the optional parent of the current DataHolder There can be no parent if the current DataHolder is the root

Specified by:

getParentDataHolder in interface DataHolder

Specified by:

getParentDataHolder in interface ModelAwareDataHolder

Returns:

the parent of the current DataHolder

getRootDataHolder

public ModelAwareDataHolder getRootDataHolder()

Description copied from interface: DataHolder

Retrieves the DataHolder that is the root of the current one

Specified by:

getRootDataHolder in interface DataHolder

Specified by:

getRootDataHolder in interface ModelAwareDataHolder

Returns:

the root DataHolder

checkDefinition

protected void checkDefinition(String dataPath,
 String errorMsg)
                        throws UndefinedItemPathException

Check definition for data path

Parameters:

dataPath - the data path

errorMsg - the error message to throw

Throws:

UndefinedItemPathException - if the definition is not found for the given data path

checkDefinition

protected void checkDefinition(String dataPath,
 boolean checkStatusAvailable,
 String errorMsg)
                        throws UndefinedItemPathException

Check definition for data path

Parameters:

dataPath - the data path

checkStatusAvailable - true to check if the definition supports externalizable data status

errorMsg - the error message to throw

Throws:

UndefinedItemPathException - if the definition is not found for the given data path