java.lang.Object
- org.ametys.plugins.repository.data.holder.impl.DefaultModelAwareDataHolder

All Implemented Interfaces:

DataHolder, ModelAwareDataHolder

Direct Known Subclasses:

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, COMMENTS_SUFFIX, STATUS_SUFFIX

Constructor Summary

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

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private <T> T`	`_aggregateMultipleValues(List<? extends ModelAwareDataHolder> dataHolders, String dataPath, Class managedClass)`
`private void`	`_ensureNonNullItemContainers()`
`protected ModelAwareComposite`	`_getComposite(String name, CompositeDefinition compositeDefinition)`	Retrieves the composite with the given name
`protected Class`	`_getCompositeClass()`	Retrieves the class of the managed composites
`private ModelAwareComposite`	`_getCompositeFromValue(Object value, String compositePath)`
`private <T> T`	`_getElementValue(ElementDefinition definition, String dataName)`
`private <T> T`	`_getGroupValue(ModelItem modelItem, String dataName)`
`private Class`	`_getManagedClass(ModelAwareDataHolder dataHolder, String dataPath)`
`private <T> T`	`_getMultipleValues(String dataPath)`
`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
`private ModelAwareRepeater`	`_getRepeaterFromValue(Object value, String repeaterPath)`
`private <T> T`	`_getValue(String dataPath, boolean allowMultiValuedPathSegments, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)`
`private boolean`	`_hasNonEmptyValue(String dataPath, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)`
`private boolean`	`_hasValue(String dataPath, Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)`
`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
`List<DataComment>`	`getComments(String dataName)`	Retrieve the comments of the data with the given name
`ModelAwareComposite`	`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
`ModelAwareComposite`	`getExternalComposite(String compositePath)`	Retrieves the external composite at the given path
`ModelAwareRepeater`	`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
`ModelAwareComposite`	`getLocalComposite(String compositePath)`	Retrieves the local composite at the given path
`ModelAwareRepeater`	`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 ModelAwareDataHolder>`	`getParentDataHolder()`	Retrieves the optional parent of the current `DataHolder` There can be no parent if the current `DataHolder` is the root
`ModelAwareRepeater`	`getRepeater(String repeaterPath)`	Retrieves the repeater at the given path
`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
`<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`	`hasDefinition(String path)`	Checks if there is a definition at the given path
`boolean`	`hasExternalValue(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 local value for the data at the given path
`boolean`	`hasNonEmptyExternalValue(String dataPath)`	Checks if there is a non empty external value for the data at the given path
`boolean`	`hasNonEmptyLocalValue(String dataPath)`	Checks if there is a non empty local value for the data at the given path
`boolean`	`hasNonEmptyValue(String dataPath)`	Checks if there is a non empty value for the data at the given path
`boolean`	`hasValue(String dataPath)`	Checks if there is a value 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, dataToSAX

Methods inherited from interface org.ametys.plugins.repository.data.holder.ModelAwareDataHolder
commentsToSAX, dataToMap, dataToMap, dataToMap, dataToMap, dataToSAX, dataToSAX, dataToSAX, dataToSAX, dataToSAXForEdition, getType, getValue, isMultiple

- Field Detail
  - _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 Detail
  - DefaultModelAwareDataHolder
```
public DefaultModelAwareDataHolder(RepositoryData repositoryData,
                                   ModelItemContainer... itemContainers)
```
    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.
  - DefaultModelAwareDataHolder
```
public DefaultModelAwareDataHolder(RepositoryData repositoryData,
                                   Collection<? extends ModelItemContainer> itemContainers)
```
    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.
  - DefaultModelAwareDataHolder
```
public DefaultModelAwareDataHolder(RepositoryData repositoryData,
                                   Optional<? extends ModelAwareDataHolder> parent,
                                   Optional<? extends ModelAwareDataHolder> root,
                                   ModelItemContainer... itemContainers)
```
    Creates a default model aware data holder
    
    Parameters:
    
    repositoryData - the repository data to use
    
    parent - the optional parent of the created DataHolder, empty if the created DataHolder is the root DataHolder
    
    root - the root DataAwareAmetysObject
    
    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.
  - DefaultModelAwareDataHolder
```
public DefaultModelAwareDataHolder(RepositoryData repositoryData,
                                   Optional<? extends ModelAwareDataHolder> parent,
                                   Optional<? extends ModelAwareDataHolder> root,
                                   Collection<? extends ModelItemContainer> itemContainers)
```
    Creates a default model aware data holder
    
    Parameters:
    
    repositoryData - the repository data to use
    
    parent - the parent of the created DataHolder, empty if the created DataHolder is the root DataHolder
    
    root - the root DataAwareAmetysObject
    
    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.
- Method Detail
  - _ensureNonNullItemContainers
```
private void _ensureNonNullItemContainers()
```
  - getComposite
```
public ModelAwareComposite 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 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 ModelAwareComposite 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 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 ModelAwareComposite 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 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
  - _getCompositeFromValue
```
private ModelAwareComposite _getCompositeFromValue(Object value,
                                                   String compositePath)
```
  - getRepeater
```
public ModelAwareRepeater 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 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 ModelAwareRepeater 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 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 ModelAwareRepeater 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 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
  - _getRepeaterFromValue
```
private ModelAwareRepeater _getRepeaterFromValue(Object value,
                                                 String repeaterPath)
```
  - 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
  - _getValue
```
private <T> T _getValue(String dataPath,
                        boolean allowMultiValuedPathSegments,
                        Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)
                 throws IllegalArgumentException,
                        UndefinedItemPathException,
                        BadItemTypeException,
                        BadDataPathCardinalityException
```
    Throws:
    
    IllegalArgumentException
    
    UndefinedItemPathException
    
    BadItemTypeException
    
    BadDataPathCardinalityException
  - 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
    
    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
  - _getElementValue
```
private <T> T _getElementValue(ElementDefinition definition,
                               String dataName)
```
  - _getGroupValue
```
private <T> T _getGroupValue(ModelItem modelItem,
                             String dataName)
```
  - _getMultipleValues
```
private <T> T _getMultipleValues(String dataPath)
```
  - _getManagedClass
```
private Class _getManagedClass(ModelAwareDataHolder dataHolder,
                               String dataPath)
```
  - _aggregateMultipleValues
```
private <T> T _aggregateMultipleValues(List<? extends ModelAwareDataHolder> dataHolders,
                                       String dataPath,
                                       Class managedClass)
```
  - _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:
    
    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
    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 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 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
  - hasLocalValue
```
public boolean hasLocalValue(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:
    
    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 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
  - hasExternalValue
```
public boolean hasExternalValue(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:
    
    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 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
  - _hasValue
```
private boolean _hasValue(String dataPath,
                          Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)
                   throws IllegalArgumentException,
                          BadDataPathCardinalityException
```
    Throws:
    
    IllegalArgumentException
    
    BadDataPathCardinalityException
  - hasNonEmptyValue
```
public boolean hasNonEmptyValue(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:
    
    hasNonEmptyValue in interface DataHolder
    
    Specified by:
    
    hasNonEmptyValue 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
  - hasNonEmptyLocalValue
```
public boolean hasNonEmptyLocalValue(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:
    
    hasNonEmptyLocalValue 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
  - hasNonEmptyExternalValue
```
public boolean hasNonEmptyExternalValue(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:
    
    hasNonEmptyExternalValue 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
  - _hasNonEmptyValue
```
private boolean _hasNonEmptyValue(String dataPath,
                                  Optional<ExternalizableDataProvider.ExternalizableDataStatus> status)
                           throws IllegalArgumentException,
                                  BadDataPathCardinalityException
```
    Throws:
    
    IllegalArgumentException
    
    BadDataPathCardinalityException
  - 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
  - hasDefinition
```
public boolean hasDefinition(String path)
                      throws IllegalArgumentException
```
    Description copied from interface: ModelAwareDataHolder
    
    Checks if there is a definition at the given path
    
    Specified by:
    
    hasDefinition in interface ModelAwareDataHolder
    
    Parameters:
    
    path - path of the data. No matter if it is a definition or data path (with repeater entry positions)
    
    Returns:
    
    true if there is definition at the given path, false otherwise
    
    Throws:
    
    IllegalArgumentException - if the given path is null or empty
  - dataToSAX
```
public void dataToSAX(ContentHandler contentHandler,
                      String dataPath,
                      DataContext context)
               throws SAXException,
                      IOException
```
    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
    
    IOException - if an error occurs while reading a value using the I/O API
  - 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
  - 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

Class DefaultModelAwareDataHolder

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

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

Field Detail

_repositoryData

_parent

_root

_itemContainers

Constructor Detail

DefaultModelAwareDataHolder

DefaultModelAwareDataHolder

DefaultModelAwareDataHolder

DefaultModelAwareDataHolder

Method Detail

_ensureNonNullItemContainers

getComposite

getLocalComposite

getExternalComposite

_getCompositeFromValue

getRepeater

getLocalRepeater

getExternalRepeater

_getRepeaterFromValue

getValue

getLocalValue

getExternalValue

_getValue

getStatus

_getElementValue

_getGroupValue

_getMultipleValues

_getManagedClass

_aggregateMultipleValues

_getRepeaterEntryClass

_getRepeaterClass

_getCompositeClass

getValue

_getComposite

_getRepeater

getComments

hasValue

hasLocalValue

hasExternalValue

_hasValue

hasNonEmptyValue

hasNonEmptyLocalValue

hasNonEmptyExternalValue

_hasNonEmptyValue

hasComments

getModel

getDefinition

hasDefinition

dataToSAX

getDataNames

getRepositoryData

getParentDataHolder

getRootDataHolder