DataObjectWrapperBase (Rice 2.5.1-SNAPSHOT API)

java.lang.Object
- org.kuali.rice.krad.data.provider.impl.DataObjectWrapperBase<T>

Type Parameters:
T - the type of the data object to wrap.

All Implemented Interfaces:

DataObjectWrapper<T>, org.springframework.beans.BeanWrapper, org.springframework.beans.ConfigurablePropertyAccessor, org.springframework.beans.PropertyAccessor, org.springframework.beans.PropertyEditorRegistry, org.springframework.beans.TypeConverter
```
public abstract class DataObjectWrapperBase<T>
extends Object
implements DataObjectWrapper<T>
```
The base implementation of DataObjectWrapper.

Author:

Kuali Rice Team (rice.collab@kuali.org)

Field Summary
- Fields inherited from interface org.springframework.beans.PropertyAccessor
  NESTED_PROPERTY_SEPARATOR, NESTED_PROPERTY_SEPARATOR_CHAR, PROPERTY_KEY_PREFIX, PROPERTY_KEY_PREFIX_CHAR, PROPERTY_KEY_SUFFIX, PROPERTY_KEY_SUFFIX_CHAR

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`DataObjectWrapperBase(T dataObject, DataObjectMetadata metadata, DataObjectService dataObjectService, ReferenceLinker referenceLinker)` Creates a data object wrapper.

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`areAllPrimaryKeyAttributesPopulated()` Returns whether all fields in the primary key are populated with a non-null/non-blank value.
`boolean`	`areAnyPrimaryKeyAttributesPopulated()` Returns whether any fields in the primary key is populated with a non-null/non-blank value.
`<Y> Y`	`convertIfNecessary(Object value, Class<Y> requiredType)`
`<Y> Y`	`convertIfNecessary(Object value, Class<Y> requiredType, Field field)`
`<Y> Y`	`convertIfNecessary(Object value, Class<Y> requiredType, org.springframework.core.MethodParameter methodParam)`
`boolean`	`equalsByPrimaryKey(T object)` Determines if the given data object is equal to the data object wrapped by this accessor based on primary key values only.
`protected void`	`fetchRelationship(MetadataChild relationship, boolean useForeignKeyAttribute, boolean nullifyDanglingRelationship)` Fetches and populates the value for the relationship with the given name on the wrapped object.
`void`	`fetchRelationship(String relationshipName)` Fetches and populates the value for the relationship with the given name on the wrapped data object.
`void`	`fetchRelationship(String relationshipName, boolean useForeignKeyAttribute, boolean nullifyDanglingRelationship)` Fetches and populates the value for the relationship with the given name on the wrapped object.
`protected void`	`fetchRelationshipUsingAttributes(MetadataChild relationship, boolean nullifyDanglingRelationship)` Fetches the relationship using the foreign key attributes.
`protected void`	`fetchRelationshipUsingIdentity(MetadataChild relationship, boolean nullifyDanglingRelationship)` Fetches the relationship using the primary key attributes.
`PropertyEditor`	`findCustomEditor(Class<?> requiredType, String propertyPath)`
`int`	`getAutoGrowCollectionLimit()`
`Collection<MetadataChild>`	`getChildrenMatchingOptions(MaterializeOption... options)` This method retrieves the `MetadataChild` objects (`DataObjectRelationship` or `DataObjectCollection`) which match the given `MaterializeOption` options.
`org.springframework.core.convert.ConversionService`	`getConversionService()`
`Map<String,Object>`	`getForeignKeyAttributeMap(String relationshipName)` Gets the map of child attribute names to the parent attribute values.
`Object`	`getForeignKeyAttributeValue(String relationshipName)` As `DataObjectWrapper.getForeignKeyValue(String)` except only returns the value for the "attribute" foreign key value.
`Object`	`getForeignKeyValue(String relationshipName)` Returns the value of the foreign key for the specified relationship on the wrapped data object, or null if the wrapped object has no value for the requested foreign key.
`DataObjectMetadata`	`getMetadata()` Returns the metadata of the data object wrapped by this accessor.
`Object`	`getPrimaryKeyValue()` Returns the value of the primary key for the wrapped data object, or null if the wrapped object has no value for it's primary key.
`Map<String,Object>`	`getPrimaryKeyValues()` Returns a map containing the values of the primary keys on this data object.
`PropertyDescriptor`	`getPropertyDescriptor(String propertyName)`
`PropertyDescriptor[]`	`getPropertyDescriptors()`
`Class<?>`	`getPropertyType(String propertyName)`
`org.springframework.core.convert.TypeDescriptor`	`getPropertyTypeDescriptor(String propertyName)`
`Class<?>`	`getPropertyTypeNullSafe(Class<?> objectType, String propertyName)` Get property type for property name on object, this can be a nested property and method will recursively use the metadata to find type.
`Object`	`getPropertyValue(String propertyName)`
`Object`	`getPropertyValueNullSafe(String propertyName)` Get the current value of the specified property, but suppresses any `NullValueInNestedPathException`s that would be thrown if a null value is encountered in a nested path and just returns null instead.
`List<String>`	`getUnpopulatedPrimaryKeyAttributeNames()` Returns the list of field of the primary key which have a null or blank value.
`Class<T>`	`getWrappedClass()` Return the type of the wrapped data object.
`T`	`getWrappedInstance()` Returns the data object wrapped by this accessor.
`boolean`	`isAutoGrowNestedPaths()`
`boolean`	`isExtractOldValueForEditor()`
`boolean`	`isReadableProperty(String propertyName)`
`boolean`	`isWritableProperty(String propertyName)`
`void`	`linkChanges(Set<String> changedPropertyPaths)` Executes reference linking using the wrapped object as the root and the set of changed paths.
`void`	`linkForeignKeys(boolean onlyLinkReadOnly)` Links foreign key values on the wrapped data object and then recurses through all child relationships and collections which are cascaded during persistence and does the same.
`void`	`linkForeignKeys(String relationshipName, boolean onlyLinkReadOnly)` Links foreign keys non-recursively using the relationship with the given name on the wrapped data object.
`protected void`	`linkForeignKeysInternal(DataObjectWrapper<?> wrapped, MetadataChild relationship, Object relationshipValue, boolean onlyLinkReadOnly)` Links foreign keys non-recursively using the relationship with the given name on the wrapped data object.
`protected void`	`linkForeignKeysInternal(Object object, boolean onlyLinkReadOnly, Set<Object> linked)` Links all foreign keys on the data object.
`protected void`	`linkForeignKeysInternalWrapped(DataObjectWrapper<?> wrapped, boolean onlyLinkReadOnly, Set<Object> linked)` Links all foreign keys on the wrapped data object.
`void`	`materializeReferencedObjects(MaterializeOption... options)` Fetches and populates referenced objects within the wrapped object.
`void`	`materializeReferencedObjectsToDepth(int maxDepth, MaterializeOption... options)` Fetches and populates referenced objects within the wrapped object.
`protected void`	`populateInverseRelationship(MetadataChild relationship, Object propertyValue)` Populates the property on the other side of the relationship.
`void`	`registerCustomEditor(Class<?> requiredType, PropertyEditor propertyEditor)`
`void`	`registerCustomEditor(Class<?> requiredType, String propertyPath, PropertyEditor propertyEditor)`
`void`	`setAutoGrowCollectionLimit(int autoGrowCollectionLimit)`
`void`	`setAutoGrowNestedPaths(boolean autoGrowNestedPaths)`
`void`	`setConversionService(org.springframework.core.convert.ConversionService conversionService)`
`void`	`setExtractOldValueForEditor(boolean extractOldValueForEditor)`
`void`	`setPropertyValue(org.springframework.beans.PropertyValue pv)`
`void`	`setPropertyValue(String propertyName, Object value)`
`void`	`setPropertyValues(Map<?,?> map)`
`void`	`setPropertyValues(org.springframework.beans.PropertyValues pvs)`
`void`	`setPropertyValues(org.springframework.beans.PropertyValues pvs, boolean ignoreUnknown)`
`void`	`setPropertyValues(org.springframework.beans.PropertyValues pvs, boolean ignoreUnknown, boolean ignoreInvalid)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - DataObjectWrapperBase
```
protected DataObjectWrapperBase(T dataObject,
                     DataObjectMetadata metadata,
                     DataObjectService dataObjectService,
                     ReferenceLinker referenceLinker)
```
    Creates a data object wrapper.
    
    Parameters:
    dataObject - the data object to wrap.
    metadata - the metadata of the data object.
    dataObjectService - the data object service to use.
    referenceLinker - the reference linker implementation.
- Method Detail
  - getMetadata
```
public DataObjectMetadata getMetadata()
```
    Returns the metadata of the data object wrapped by this accessor.
    
    Specified by:
    
    getMetadata in interface DataObjectWrapper<T>
    
    Returns:
    the metadata of the data object wrapped by this accessor
  - getWrappedInstance
```
public T getWrappedInstance()
```
    Returns the data object wrapped by this accessor.
    
    Specified by:
    
    getWrappedInstance in interface DataObjectWrapper<T>
    
    Specified by:
    
    getWrappedInstance in interface org.springframework.beans.BeanWrapper
    
    Returns:
    the data object wrapped by this accessor
  - getPropertyValueNullSafe
```
public Object getPropertyValueNullSafe(String propertyName)
                                throws org.springframework.beans.BeansException
```
    Get the current value of the specified property, but suppresses any NullValueInNestedPathExceptions that would be thrown if a null value is encountered in a nested path and just returns null instead. This method is essentially a convenience method to prevent calling code from having to wrap calls to PropertyAccessor.getPropertyValue(String) with a try-catch block to check for NullValueInNestedPathExceptions.
    
    Specified by:
    
    getPropertyValueNullSafe in interface DataObjectWrapper<T>
    
    Parameters:
    propertyName - the name of the property to get the value of (may be a nested path and/or an indexed/mapped property)
    
    Returns:
    the value of the property, or null if any null values were encountered in nested paths
    
    Throws:
    
    org.springframework.beans.InvalidPropertyException - if there is no such property or if the property isn't readable
    
    org.springframework.beans.PropertyAccessException - if the property was valid but the accessor method failed
    
    org.springframework.beans.BeansException
  - getWrappedClass
```
public Class<T> getWrappedClass()
```
    Return the type of the wrapped data object.
    
    Specified by:
    
    getWrappedClass in interface DataObjectWrapper<T>
    
    Specified by:
    
    getWrappedClass in interface org.springframework.beans.BeanWrapper
    
    Returns:
    the type of the wrapped data instance, or null if no wrapped object has been set
  - getPropertyDescriptors
```
public PropertyDescriptor[] getPropertyDescriptors()
```
    Specified by:
    
    getPropertyDescriptors in interface org.springframework.beans.BeanWrapper
  - getPropertyDescriptor
```
public PropertyDescriptor getPropertyDescriptor(String propertyName)
                                         throws org.springframework.beans.InvalidPropertyException
```
    Specified by:
    
    getPropertyDescriptor in interface org.springframework.beans.BeanWrapper
    
    Throws:
    
    org.springframework.beans.InvalidPropertyException
  - setAutoGrowNestedPaths
```
public void setAutoGrowNestedPaths(boolean autoGrowNestedPaths)
```
    Specified by:
    
    setAutoGrowNestedPaths in interface org.springframework.beans.BeanWrapper
  - isAutoGrowNestedPaths
```
public boolean isAutoGrowNestedPaths()
```
    Specified by:
    
    isAutoGrowNestedPaths in interface org.springframework.beans.BeanWrapper
  - setAutoGrowCollectionLimit
```
public void setAutoGrowCollectionLimit(int autoGrowCollectionLimit)
```
    Specified by:
    
    setAutoGrowCollectionLimit in interface org.springframework.beans.BeanWrapper
  - getAutoGrowCollectionLimit
```
public int getAutoGrowCollectionLimit()
```
    Specified by:
    
    getAutoGrowCollectionLimit in interface org.springframework.beans.BeanWrapper
  - setConversionService
```
public void setConversionService(org.springframework.core.convert.ConversionService conversionService)
```
    Specified by:
    
    setConversionService in interface org.springframework.beans.ConfigurablePropertyAccessor
  - getConversionService
```
public org.springframework.core.convert.ConversionService getConversionService()
```
    Specified by:
    
    getConversionService in interface org.springframework.beans.ConfigurablePropertyAccessor
  - setExtractOldValueForEditor
```
public void setExtractOldValueForEditor(boolean extractOldValueForEditor)
```
    Specified by:
    
    setExtractOldValueForEditor in interface org.springframework.beans.ConfigurablePropertyAccessor
  - isExtractOldValueForEditor
```
public boolean isExtractOldValueForEditor()
```
    Specified by:
    
    isExtractOldValueForEditor in interface org.springframework.beans.ConfigurablePropertyAccessor
  - isReadableProperty
```
public boolean isReadableProperty(String propertyName)
```
    Specified by:
    
    isReadableProperty in interface org.springframework.beans.PropertyAccessor
  - isWritableProperty
```
public boolean isWritableProperty(String propertyName)
```
    Specified by:
    
    isWritableProperty in interface org.springframework.beans.PropertyAccessor
  - getPropertyType
```
public Class<?> getPropertyType(String propertyName)
                         throws org.springframework.beans.BeansException
```
    Specified by:
    
    getPropertyType in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - getPropertyTypeDescriptor
```
public org.springframework.core.convert.TypeDescriptor getPropertyTypeDescriptor(String propertyName)
                                                                          throws org.springframework.beans.BeansException
```
    Specified by:
    
    getPropertyTypeDescriptor in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - getPropertyValue
```
public Object getPropertyValue(String propertyName)
                        throws org.springframework.beans.BeansException
```
    Specified by:
    
    getPropertyValue in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - setPropertyValue
```
public void setPropertyValue(String propertyName,
                    Object value)
                      throws org.springframework.beans.BeansException
```
    Specified by:
    
    setPropertyValue in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - setPropertyValue
```
public void setPropertyValue(org.springframework.beans.PropertyValue pv)
                      throws org.springframework.beans.BeansException
```
    Specified by:
    
    setPropertyValue in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - setPropertyValues
```
public void setPropertyValues(Map<?,?> map)
                       throws org.springframework.beans.BeansException
```
    Specified by:
    
    setPropertyValues in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - setPropertyValues
```
public void setPropertyValues(org.springframework.beans.PropertyValues pvs)
                       throws org.springframework.beans.BeansException
```
    Specified by:
    
    setPropertyValues in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - setPropertyValues
```
public void setPropertyValues(org.springframework.beans.PropertyValues pvs,
                     boolean ignoreUnknown)
                       throws org.springframework.beans.BeansException
```
    Specified by:
    
    setPropertyValues in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - setPropertyValues
```
public void setPropertyValues(org.springframework.beans.PropertyValues pvs,
                     boolean ignoreUnknown,
                     boolean ignoreInvalid)
                       throws org.springframework.beans.BeansException
```
    Specified by:
    
    setPropertyValues in interface org.springframework.beans.PropertyAccessor
    
    Throws:
    
    org.springframework.beans.BeansException
  - registerCustomEditor
```
public void registerCustomEditor(Class<?> requiredType,
                        PropertyEditor propertyEditor)
```
    Specified by:
    
    registerCustomEditor in interface org.springframework.beans.PropertyEditorRegistry
  - registerCustomEditor
```
public void registerCustomEditor(Class<?> requiredType,
                        String propertyPath,
                        PropertyEditor propertyEditor)
```
    Specified by:
    
    registerCustomEditor in interface org.springframework.beans.PropertyEditorRegistry
  - findCustomEditor
```
public PropertyEditor findCustomEditor(Class<?> requiredType,
                              String propertyPath)
```
    Specified by:
    
    findCustomEditor in interface org.springframework.beans.PropertyEditorRegistry
  - convertIfNecessary
```
public <Y> Y convertIfNecessary(Object value,
                       Class<Y> requiredType)
                     throws org.springframework.beans.TypeMismatchException
```
    Specified by:
    
    convertIfNecessary in interface org.springframework.beans.TypeConverter
    
    Throws:
    
    org.springframework.beans.TypeMismatchException
  - convertIfNecessary
```
public <Y> Y convertIfNecessary(Object value,
                       Class<Y> requiredType,
                       org.springframework.core.MethodParameter methodParam)
                     throws org.springframework.beans.TypeMismatchException
```
    Specified by:
    
    convertIfNecessary in interface org.springframework.beans.TypeConverter
    
    Throws:
    
    org.springframework.beans.TypeMismatchException
  - convertIfNecessary
```
public <Y> Y convertIfNecessary(Object value,
                       Class<Y> requiredType,
                       Field field)
                     throws org.springframework.beans.TypeMismatchException
```
    Specified by:
    
    convertIfNecessary in interface org.springframework.beans.TypeConverter
    
    Throws:
    
    org.springframework.beans.TypeMismatchException
  - getPrimaryKeyValues
```
public Map<String,Object> getPrimaryKeyValues()
```
    Returns a map containing the values of the primary keys on this data object. The key of this map will be the attribute name of the primary key field on the data object and the value will the value of that primary key attribute on the data object wrapped by this accessor. If this data object has no primary key fields, an empty map will be returned.
    
    Specified by:
    
    getPrimaryKeyValues in interface DataObjectWrapper<T>
    
    Returns:
    a map of primary key values where the key is the attribute name of the primary key field and the value is the value of that primary key field on the wrapped data object
  - getPrimaryKeyValue
```
public Object getPrimaryKeyValue()
```
    Returns the value of the primary key for the wrapped data object, or null if the wrapped object has no value for it's primary key.
    If the primary key consists of multiple values, this method will return an instance of CompoundKey, otherwise the single primary key value will be returned. If the primary key consists of multiple values but those values are only partially populated, this method will return null.
    
    Specified by:
    
    getPrimaryKeyValue in interface DataObjectWrapper<T>
    
    Returns:
    the single primary key value for the wrapped data object, or null if it has no fully-populated primary key value
  - areAllPrimaryKeyAttributesPopulated
```
public boolean areAllPrimaryKeyAttributesPopulated()
```
    Returns whether all fields in the primary key are populated with a non-null/non-blank value.
    
    Specified by:
    
    areAllPrimaryKeyAttributesPopulated in interface DataObjectWrapper<T>
  - areAnyPrimaryKeyAttributesPopulated
```
public boolean areAnyPrimaryKeyAttributesPopulated()
```
    Returns whether any fields in the primary key is populated with a non-null/non-blank value.
    
    Specified by:
    
    areAnyPrimaryKeyAttributesPopulated in interface DataObjectWrapper<T>
  - getUnpopulatedPrimaryKeyAttributeNames
```
public List<String> getUnpopulatedPrimaryKeyAttributeNames()
```
    Returns the list of field of the primary key which have a null or blank value.
    
    Specified by:
    
    getUnpopulatedPrimaryKeyAttributeNames in interface DataObjectWrapper<T>
  - equalsByPrimaryKey
```
public boolean equalsByPrimaryKey(T object)
```
    Determines if the given data object is equal to the data object wrapped by this accessor based on primary key values only. If the given object is null, then this method will always return false.
    
    Specified by:
    
    equalsByPrimaryKey in interface DataObjectWrapper<T>
    
    Parameters:
    object - the object to compare to the data object wrapped by this accessor
    
    Returns:
    true if the primary key values are equal, false otherwise
  - getForeignKeyValue
```
public Object getForeignKeyValue(String relationshipName)
```
    Returns the value of the foreign key for the specified relationship on the wrapped data object, or null if the wrapped object has no value for the requested foreign key.
    If the foreign key is a compound/composite and consists of multiple values, this method will return an instance of CompoundKey, otherwise the single foreign key value will be returned. If the foreign key is compound/composite but those values are only partially populated, this method will return null.
    
    It is common that a data object may have more than one field or set of fields that constitute a specific foreign key for the specified relationship. In such cases there would be an attribute (or attributes) which represent the foreign key as well as the related object itself. For example, consider the following scenario:
```
 public class One {
     String twoId;
     Two two;
 }
 
 
```
    In this case, twoId is an attribute that serves as a foreign key to Two, but the two attribute would contain an internal twoId attribute which is the primary key value for Two and represents the foreign key in this case.
    
    In cases like above, the twoId attribute on the One class would take precedence unless it contains a null value, in which case this method will attempt to extract a non-null foreign key value from the related object.
    Specified by:
    
    getForeignKeyValue in interface DataObjectWrapper<T>
    
    Parameters:
    relationshipName - the name of the relationship on the wrapped data object for which to determine the foreign key value
    
    Returns:
    the single foreign key value on the wrapped data object for the given relationship name, or null if it has no fully-populated foreign key value
  - getForeignKeyAttributeValue
```
public Object getForeignKeyAttributeValue(String relationshipName)
```
    As DataObjectWrapper.getForeignKeyValue(String) except only returns the value for the "attribute" foreign key value. If the wrapped data object has no attribute foreign key for the given relationship, this method will return null.
    
    Specified by:
    
    getForeignKeyAttributeValue in interface DataObjectWrapper<T>
    
    Parameters:
    relationshipName - the name of the relationship on the wrapped data object for which to determine the foreign key value
    
    Returns:
    the single foreign key attribute value on the wrapped data object for the given relationship name, or null if it has no fully-populated foreign key attribute value
  - getForeignKeyAttributeMap
```
public Map<String,Object> getForeignKeyAttributeMap(String relationshipName)
```
    Gets the map of child attribute names to the parent attribute values.
    
    Parameters:
    relationshipName - the name of the relationship for which to get the map.
    
    Returns:
    the map of child attribute names to the parent attribute values.
  - getPropertyTypeNullSafe
```
public Class<?> getPropertyTypeNullSafe(Class<?> objectType,
                               String propertyName)
```
    Get property type for property name on object, this can be a nested property and method will recursively use the metadata to find type.
    
    Specified by:
    
    getPropertyTypeNullSafe in interface DataObjectWrapper<T>
    
    Parameters:
    objectType - - Root object type
    propertyName - - Property name
    
    Returns:
    Class of propertyName
  - linkChanges
```
public void linkChanges(Set<String> changedPropertyPaths)
```
    Executes reference linking using the wrapped object as the root and the set of changed paths.
    Executes reference linker as per the algorithm described on ReferenceLinker
    
    Specified by:
    
    linkChanges in interface DataObjectWrapper<T>
    
    Parameters:
    changedPropertyPaths - the Set of changed property paths relative to the wrapped object
    See Also:
    ReferenceLinker.linkChanges(Object, java.util.Set)
  - linkForeignKeys
```
public void linkForeignKeys(boolean onlyLinkReadOnly)
```
    Links foreign key values on the wrapped data object and then recurses through all child relationships and collections which are cascaded during persistence and does the same.
    In this context, linking of foreign key values means that on data objects that have both a field (or fields) that represent a foreign key to a relationship as well as an actual reference object for that relationship, if that foreign key field(s) is read only, then it will copy the value of the primary key(s) on the reference object to the associated foreign key field(s).
    
    If onlyLinkReadOnly is true, this method will only link values into foreign keys that are "read-only" according to the metadata of the data object. This is to avoid situations where the foreign key field itself is the "master" value for the key. In those situations you do not want a read-only reference object to obliterate or corrupt the master key.
    
    Specified by:
    
    linkForeignKeys in interface DataObjectWrapper<T>
    
    Parameters:
    onlyLinkReadOnly - indicates whether or not only read-only foreign keys should be linked
  - linkForeignKeysInternal
```
protected void linkForeignKeysInternal(Object object,
                           boolean onlyLinkReadOnly,
                           Set<Object> linked)
```
    Links all foreign keys on the data object.
    
    Parameters:
    object - the object to link.
    onlyLinkReadOnly - whether to only link read-only objects.
    linked - the set of currently linked objects, used as a base case to exit out of recursion.
  - linkForeignKeysInternalWrapped
```
protected void linkForeignKeysInternalWrapped(DataObjectWrapper<?> wrapped,
                                  boolean onlyLinkReadOnly,
                                  Set<Object> linked)
```
    Links all foreign keys on the wrapped data object.
    
    Parameters:
    wrapped - the wrapped object to link.
    onlyLinkReadOnly - whether to only link read-only objects.
    linked - the set of currently linked objects, used as a base case to exit out of recursion.
  - fetchRelationship
```
public void fetchRelationship(String relationshipName)
```
    Fetches and populates the value for the relationship with the given name on the wrapped data object.
    This is done by identifying the current foreign key attribute value for the relationship using the algorithm described on DataObjectWrapper.getForeignKeyAttributeValue(String) and then loading the related object using that foreign key value, updating the relationship value on the wrapped data object afterward.
    
    If the foreign key value is null or the loading of the related object using the foreign key returns a null value, this method will set the relationship value to null.
    
    This method is equivalent to invoking DataObjectWrapper.fetchRelationship(String, boolean, boolean) passing "true" for both useForeignKeyAttribute and nullifyDanglingRelationship.
    
    Specified by:
    
    fetchRelationship in interface DataObjectWrapper<T>
    
    Parameters:
    relationshipName - the name of the relationship on the wrapped data object to refresh
  - fetchRelationship
```
public void fetchRelationship(String relationshipName,
                     boolean useForeignKeyAttribute,
                     boolean nullifyDanglingRelationship)
```
    Fetches and populates the value for the relationship with the given name on the wrapped object.
    The value of useForeignKeyAttribute will be used to determine whether the foreign key attribute is used to fetch the relationship (if this parameter is "true"), or whether the primary key on the related object itself will be used (if it is false). In the case that the primary key is used, once the relationship has been fetched, the foreign key field value (if one exists) will also be updated to remain in sync with the reference object.
    
    If no related object is found when attempting to fetch by the key values, then the behavior of this method will depend upon the value passed for nullifyDanglingRelationship. If false, this method will not modify the wrapped object. If true, then the related object will be set to null.
    
    Specified by:
    
    fetchRelationship in interface DataObjectWrapper<T>
    
    Parameters:
    relationshipName - the name of the relationship on the wrapped data object to refresh
    useForeignKeyAttribute - if true, use the foreign key attribute to fetch the relationship, otherwise use the primary key value on the related object
    nullifyDanglingRelationship - if true and no relationship value is found for the given key then set the related object to null, otherwise leave the existing object state alone
  - fetchRelationship
```
protected void fetchRelationship(MetadataChild relationship,
                     boolean useForeignKeyAttribute,
                     boolean nullifyDanglingRelationship)
```
    Fetches and populates the value for the relationship with the given name on the wrapped object.
    
    Parameters:
    relationship - the relationship on the wrapped data object to refresh
    useForeignKeyAttribute - whether to use the foreign key attribute to fetch the relationship
    nullifyDanglingRelationship - whether to set the related object to null if no relationship value is found
  - fetchRelationshipUsingAttributes
```
protected void fetchRelationshipUsingAttributes(MetadataChild relationship,
                                    boolean nullifyDanglingRelationship)
```
    Fetches the relationship using the foreign key attributes.
    
    Parameters:
    relationship - the relationship on the wrapped data object to refresh
    nullifyDanglingRelationship - whether to set the related object to null if no relationship value is found
  - fetchRelationshipUsingIdentity
```
protected void fetchRelationshipUsingIdentity(MetadataChild relationship,
                                  boolean nullifyDanglingRelationship)
```
    Fetches the relationship using the primary key attributes.
    
    Parameters:
    relationship - the relationship on the wrapped data object to refresh
    nullifyDanglingRelationship - whether to set the related object to null if no relationship value is found
  - linkForeignKeys
```
public void linkForeignKeys(String relationshipName,
                   boolean onlyLinkReadOnly)
```
    Links foreign keys non-recursively using the relationship with the given name on the wrapped data object.
    If onlyLinkReadOnly is true then it will only perform linking for foreign key fields that are "read-only" according to the metadata for the data object. This is to avoid situations where the foreign key field itself is the "master" value for the key. In those situations you do not want a read-only reference object to obliterate or corrupt the master key.
    
    Specified by:
    
    linkForeignKeys in interface DataObjectWrapper<T>
    
    Parameters:
    relationshipName - the name of the relationship on the wrapped data object for which to link foreign keys, must not be a nested path
    onlyLinkReadOnly - indicates whether or not only read-only foreign keys should be linked
  - materializeReferencedObjects
```
public void materializeReferencedObjects(MaterializeOption... options)
```
    Fetches and populates referenced objects within the wrapped object. See DataObjectWrapper.fetchRelationship(String) for details on how the relationships will be fetched. By default, this method will go through and instantiate all lazy-loaded, non-persisted-with-parent reference objects and collections on the master object. See MaterializeOption for the available options. This method does not recurse into child objects. For that, use the DataObjectWrapper.materializeReferencedObjectsToDepth(int, MaterializeOption...) method.
    
    Specified by:
    
    materializeReferencedObjects in interface DataObjectWrapper<T>
    
    Parameters:
    options - An optional list of MaterializeOption objects which may adjust the behavior of this method.
    See Also:
    DataObjectWrapper.fetchRelationship(String), MaterializeOption
  - materializeReferencedObjectsToDepth
```
public void materializeReferencedObjectsToDepth(int maxDepth,
                                       MaterializeOption... options)
```
    Fetches and populates referenced objects within the wrapped object. See DataObjectWrapper.fetchRelationship(String) for details on how the relationships will be fetched. By default, this method will go through and instantiate all lazy-loaded, non-persisted-with-parent reference objects and collections on the master object. See MaterializeOption for the available options.
    
    Specified by:
    
    materializeReferencedObjectsToDepth in interface DataObjectWrapper<T>
    
    Parameters:
    maxDepth - The number of levels of child objects to refresh. A value of 1 will only materialize the child object on the wrapped object.
    options - An optional list of MaterializeOption objects which may adjust the behavior of this method.
    See Also:
    DataObjectWrapper.fetchRelationship(String), MaterializeOption
  - getChildrenMatchingOptions
```
public Collection<MetadataChild> getChildrenMatchingOptions(MaterializeOption... options)
```
    This method retrieves the MetadataChild objects (DataObjectRelationship or DataObjectCollection) which match the given MaterializeOption options. It utilizes the known information in the DataObjectMetadata and compares the flags there with the options given. If no options are given, this method will return all DataObjectRelationship and DataObjectCollection objects which are not updatable (not MetadataChild.isSavedWithParent()) and are lazily loaded (MetadataChild.isLoadedDynamicallyUponUse()).
    
    Parameters:
    options - An optional list of MaterializeOption objects to alter the default behavior.
    
    Returns:
    A non-null collection of MetadataChild objects matching the given parameters.
  - linkForeignKeysInternal
```
protected void linkForeignKeysInternal(DataObjectWrapper<?> wrapped,
                           MetadataChild relationship,
                           Object relationshipValue,
                           boolean onlyLinkReadOnly)
```
    Links foreign keys non-recursively using the relationship with the given name on the wrapped data object.
    
    Parameters:
    wrapped - the wrapped object to link.
    relationship - the relationship on the wrapped data object for which to link foreign keys.
    relationshipValue - the value of the relationship.
    onlyLinkReadOnly - indicates whether or not only read-only foreign keys should be linked.
  - populateInverseRelationship
```
protected void populateInverseRelationship(MetadataChild relationship,
                               Object propertyValue)
```
    Populates the property on the other side of the relationship.
    
    Parameters:
    relationship - the relationship on the wrapped data object for which to populate the inverse relationship.
    propertyValue - the value of the property.

Class DataObjectWrapperBase<T>

Field Summary

Fields inherited from interface org.springframework.beans.PropertyAccessor

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

DataObjectWrapperBase

Method Detail

getMetadata

getWrappedInstance

getPropertyValueNullSafe

getWrappedClass

getPropertyDescriptors

getPropertyDescriptor

setAutoGrowNestedPaths

isAutoGrowNestedPaths

setAutoGrowCollectionLimit

getAutoGrowCollectionLimit

setConversionService

getConversionService

setExtractOldValueForEditor

isExtractOldValueForEditor

isReadableProperty

isWritableProperty

getPropertyType

getPropertyTypeDescriptor

getPropertyValue

setPropertyValue

setPropertyValue

setPropertyValues

setPropertyValues

setPropertyValues

setPropertyValues

registerCustomEditor

registerCustomEditor

findCustomEditor

convertIfNecessary

convertIfNecessary

convertIfNecessary

getPrimaryKeyValues

getPrimaryKeyValue

areAllPrimaryKeyAttributesPopulated

areAnyPrimaryKeyAttributesPopulated

getUnpopulatedPrimaryKeyAttributeNames

equalsByPrimaryKey

getForeignKeyValue

getForeignKeyAttributeValue

getForeignKeyAttributeMap

getPropertyTypeNullSafe

linkChanges

linkForeignKeys

linkForeignKeysInternal

linkForeignKeysInternalWrapped

fetchRelationship

fetchRelationship

fetchRelationship

fetchRelationshipUsingAttributes

fetchRelationshipUsingIdentity

linkForeignKeys

materializeReferencedObjects

materializeReferencedObjectsToDepth

getChildrenMatchingOptions

linkForeignKeysInternal

populateInverseRelationship