Package org.ametys.cms.data.holder.impl

Class DefaultModelAwareDataHolder

java.lang.Object

org.ametys.cms.data.holder.impl.DefaultModelAwareDataHolder

All Implemented Interfaces:

IndexableDataHolder, DataHolder, ModelAwareDataHolder

Direct Known Subclasses:

DefaultModifiableModelAwareDataHolder

public class DefaultModelAwareDataHolder
extends Object
implements IndexableDataHolder

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 IndexableDataHolder>	_parent	Parent of the current DataHolder
protected RepositoryData	_repositoryData	Repository data to use to store data in the repository
protected IndexableDataHolder	_root	Root DataHolder

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

ALTERNATIVE_SUFFIX, COMMENTS_SUFFIX, STATUS_SUFFIX

Constructor Summary

Constructors

Constructor	Description
DefaultModelAwareDataHolder(RepositoryData repositoryData, Collection<? extends ModelItemContainer> itemContainers, Optional<? extends IndexableDataHolder> parent, Optional<? extends IndexableDataHolder> 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 IndexableDataHolder> parent, Optional<? extends IndexableDataHolder> 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 <T extends SynchronizationContext> T	_createSynchronizationContextInstance()	Creates an instance of SynchronizationContext
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 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 String	_getFinalDataName(String dataName, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)	Retrieves the name of the data according to the given status
protected ModelAwareDataAwareAmetysObject	_getPropertysAmetysObject(String dataPath)	Retrieves the ametys object containing the property at the given path
protected ModelAwareRepeater	_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 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
Object	dataToJSON(String dataPath, DataContext context)	Convert the data at the given path into a JSON 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
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
List<DataComment>	getComments(String dataName)	Retrieve the comments of the data with the given name
IndexableComposite	getComposite(String compositePath)	Retrieves the composite at the given path
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
ModelItem	getDefinition(String path)	Retrieves the definition of the data at the given path
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
IndexableComposite	getExternalComposite(String compositePath)	Retrieves the external composite at the given path
IndexableRepeater	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
IndexableComposite	getLocalComposite(String compositePath)	Retrieves the local composite at the given path
IndexableRepeater	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
Collection<? extends ModelItemContainer>	getModel()	Retrieves the data holder's model
Optional<? extends IndexableDataHolder>	getParentDataHolder()	Retrieves the optional parent of the current DataHolder There can be no parent if the current DataHolder is the root
IndexableRepeater	getRepeater(String repeaterPath)	Retrieves the repeater at the given path
RepositoryData	getRepositoryData()	Retrieves the repository data used by this DataHolder
IndexableDataHolder	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, boolean allowMultiValuedPathSegments)	Retrieves the value of the data at the given path
<T> T	getValue(String dataPath, boolean useDefaultFromModel, T defaultValue)	Retrieves the value of the data at the given path, or the default value The returned value is one of those ones, in the order: The value of the data if exists and is not empty The default value from the model if useDefaultFromModel is true and there is a default value defined by the model The given default value
boolean	hasComments(String dataName)	Checks if there is are comments on the data with the given name
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
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
boolean	hasValueOrEmpty(String dataPath)	Checks if there is a value, even empty, for the data at the given path

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

commentsToSAX, dataToJSON, dataToJSON, dataToJSON, dataToMap, dataToMap, dataToMap, dataToSAX, dataToSAX, dataToSAX, getType, getValue, hasDefinition, isMultiple

Field Details

_repositoryData

protected RepositoryData _repositoryData

Repository data to use to store data in the repository

_parent

protected Optional<? extends IndexableDataHolder> _parent

Parent of the current DataHolder

_root

protected IndexableDataHolder _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 IndexableDataHolder> parent,
 Optional<? extends IndexableDataHolder> 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 IndexableDataHolder> parent,
 Optional<? extends IndexableDataHolder> 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

getComposite

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

Description copied from interface: ModelAwareDataHolder

Retrieves the composite at the given path

Specified by:

getComposite in interface DataHolder

Specified by:

getComposite in interface IndexableDataHolder

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

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

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

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

getLocalComposite

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

Description copied from interface: ModelAwareDataHolder

Retrieves the local composite at the given path

Specified by:

getLocalComposite in interface IndexableDataHolder

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

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

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

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

getExternalComposite

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

Description copied from interface: ModelAwareDataHolder

Retrieves the external composite at the given path

Specified by:

getExternalComposite in interface IndexableDataHolder

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

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

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

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

getRepeater

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

Description copied from interface: ModelAwareDataHolder

Retrieves the repeater at the given path

Specified by:

getRepeater in interface IndexableDataHolder

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

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

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

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

getLocalRepeater

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

Description copied from interface: ModelAwareDataHolder

Retrieves the local repeater at the given path

Specified by:

getLocalRepeater in interface IndexableDataHolder

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

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

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

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

getExternalRepeater

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

Description copied from interface: ModelAwareDataHolder

Retrieves the external repeater at the given path

Specified by:

getExternalRepeater in interface IndexableDataHolder

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

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

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

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

getValue

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

Description copied from interface: ModelAwareDataHolder

Retrieves the value of the data at the given path

Specified by:

getValue in interface ModelAwareDataHolder

Type Parameters:

T - type of the value to retrieve

Parameters:

dataPath - path of the data

allowMultiValuedPathSegments - true to allow multi-valued segments in the path (not necessarily at the last segment), false otherwise. If true, if there is no indicated entry for a repeater, the values of all the entries are retrieved If true and if there are multiple values, all data are retrieved in one array

Returns:

the value of the data or null if allowMultiValuedPathSegments is false and there is no non empty value. The object returned may be of a generic class defined by the storage (if the model is unknown). For example, an url may be returned as a String.

Throws:

IllegalArgumentException - if the given data path is null or empty

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

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

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

getLocalValue

public <T> T getLocalValue(String dataPath)
                    throws IllegalArgumentException,
UndefinedItemPathException,
BadItemTypeException,
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

Parameters:

dataPath - path of the externalizable data

Returns:

the local value of the data or null if not exists or is empty. The object returned may be of a generic class defined by the storage (if the model is unknown). For example, an url may be returned as a String.

Throws:

IllegalArgumentException - if the given data path is null or empty

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

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

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,
UndefinedItemPathException,
BadItemTypeException,
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

Parameters:

dataPath - path of the externalizable data

Returns:

the external value of the data or null if not exists or is empty. The object returned may be of a generic class defined by the storage (if the model is unknown). For example, an url may be returned as a String.

Throws:

IllegalArgumentException - if the given data path is null or empty

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

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

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

getStatus

public ExternalizableDataProvider.ExternalizableDataStatus getStatus(String dataPath)
                                                              throws IllegalArgumentException,
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

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

_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

getValue

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

Description copied from interface: ModelAwareDataHolder

Retrieves the value of the data at the given path, or the default value The returned value is one of those ones, in the order:

1. The value of the data if exists and is not empty
2. The default value from the model if useDefaultFromModel is true and there is a default value defined by the model
3. The given default value

Specified by:

getValue in interface ModelAwareDataHolder

Type Parameters:

T - type of the value to retrieve

Parameters:

dataPath - path of the data

useDefaultFromModel - true to use the default value from the model, false to use the given default value

defaultValue - default value used if value is null and useDefaultFromModel is false, or if there is no default value on model

Returns:

the value of the data at the given path

Throws:

IllegalArgumentException - if the given data path is null or empty

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

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

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

_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

_getRepeater

protected ModelAwareRepeater _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

getComments

public List<DataComment> getComments(String dataName)
                              throws IllegalArgumentException,
UndefinedItemPathException

Description copied from interface: ModelAwareDataHolder

Retrieve the comments of the data with the given name

Specified by:

getComments in interface ModelAwareDataHolder

Parameters:

dataName - name of the data

Returns:

the comments of the data

Throws:

IllegalArgumentException - if the given data name is null or empty

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

hasValue

public boolean hasValue(String dataPath)
                 throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

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

Specified by:

hasValue in interface DataHolder

Specified by:

hasValue in interface ModelAwareDataHolder

Parameters:

dataPath - path of the data

Returns:

true if the data at the given path is defined by the model, if there is a non empty 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

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

hasValueOrEmpty

public boolean hasValueOrEmpty(String dataPath)
                        throws IllegalArgumentException,
BadDataPathCardinalityException

Description copied from interface: ModelAwareDataHolder

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

Specified by:

hasValueOrEmpty in interface DataHolder

Specified by:

hasValueOrEmpty in interface ModelAwareDataHolder

Parameters:

dataPath - path of the data

Returns:

true if the data at the given path is defined by the model, if there is a 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

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

_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

hasComments

public boolean hasComments(String dataName)
                    throws IllegalArgumentException,
UndefinedItemPathException

Description copied from interface: ModelAwareDataHolder

Checks if there is are comments on the data with the given name

Specified by:

hasComments in interface ModelAwareDataHolder

Parameters:

dataName - name of the data

Returns:

true if there are comments on the data, false otherwise

Throws:

IllegalArgumentException - if the given data name is null or empty

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

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

getDefinition

public ModelItem getDefinition(String path)
                        throws IllegalArgumentException,
UndefinedItemPathException

Description copied from interface: ModelAwareDataHolder

Retrieves the definition of the data at the given path

Specified by:

getDefinition in interface ModelAwareDataHolder

Parameters:

path - path of the data. No matter if it is a definition or data path (with repeater entry positions)

Returns:

the definition of the data

Throws:

IllegalArgumentException - if the given path is null or empty

UndefinedItemPathException - if the given path is not defined by the 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

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

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)

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

_getPropertysAmetysObject

protected ModelAwareDataAwareAmetysObject _getPropertysAmetysObject(String dataPath)
                                                             throws UndefinedItemPathException

Retrieves the ametys object containing the property at the given path

Parameters:

dataPath - the path of the property

Returns:

the ametys object containing the property

Throws:

UndefinedItemPathException - if the given path does not represent a property

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)

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.

hasDifferences

public boolean hasDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values)
                       throws UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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 UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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

_hasDifferences

protected boolean _hasDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values,
 SynchronizationContext context)
                           throws UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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 UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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 UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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

_getDifferences

protected Collection<ModelItem> _getDifferences(ViewItemAccessor viewItemAccessor,
 Map<String,Object> values,
 SynchronizationContext context)
                                         throws UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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 UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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 UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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 UndefinedItemPathException,
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:

UndefinedItemPathException - if a key in the given Map refers to a data that is not defined by the model

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 IllegalArgumentException,
UndefinedItemPathException,
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:

IllegalArgumentException - if the given data name is null or empty

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

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 IllegalArgumentException,
UndefinedItemPathException,
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:

IllegalArgumentException - if the given data name is null or empty

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

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

Specified by:

getParentDataHolder in interface ModelAwareDataHolder

Returns:

the parent of the current DataHolder

getRootDataHolder

public IndexableDataHolder 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 IndexableDataHolder

Specified by:

getRootDataHolder in interface ModelAwareDataHolder

Returns:

the root DataHolder

_checkDefinition

protected void _checkDefinition(String dataPath,
 String errorMsg)

Check definition for data path

Parameters:

dataPath - the data path

errorMsg - the error message to throw

_checkDefinition

protected void _checkDefinition(String dataPath,
 boolean checkStatusAvailable,
 String errorMsg)

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