CompositeUserType (Hibernate Core Aggregator 3.6.10.Final API)

```
public interface CompositeUserType
```
A UserType that may be dereferenced in a query. This interface allows a custom type to define "properties". These need not necessarily correspond to physical JavaBeans style properties.

A CompositeUserType may be used in almost every way that a component may be used. It may even contain many-to-one associations.

Implementors must be immutable and must declare a public default constructor.

Unlike UserType, cacheability does not depend upon serializability. Instead, assemble() and disassemble provide conversion to/from a cacheable representation.

Author:

Gavin King

See Also:
for more simple cases, Type

Method Summary

Methods
Modifier and Type	Method and Description
`Object`	`assemble(Serializable cached, SessionImplementor session, Object owner)` Reconstruct an object from the cacheable representation.
`Object`	`deepCopy(Object value)` Return a deep copy of the persistent state, stopping at entities and at collections.
`Serializable`	`disassemble(Object value, SessionImplementor session)` Transform the object into its cacheable representation.
`boolean`	`equals(Object x, Object y)` Compare two instances of the class mapped by this type for persistence "equality".
`String[]`	`getPropertyNames()` Get the "property names" that may be used in a query.
`Type[]`	`getPropertyTypes()` Get the corresponding "property types".
`Object`	`getPropertyValue(Object component, int property)` Get the value of a property.
`int`	`hashCode(Object x)` Get a hashcode for the instance, consistent with persistence "equality"
`boolean`	`isMutable()` Check if objects of this type mutable.
`Object`	`nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`void`	`nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Write an instance of the mapped class to a prepared statement.
`Object`	`replace(Object original, Object target, SessionImplementor session, Object owner)` During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
`Class`	`returnedClass()` The class returned by `nullSafeGet()`.
`void`	`setPropertyValue(Object component, int property, Object value)` Set the value of a property.

- Method Detail
  - getPropertyNames
```
String[] getPropertyNames()
```
    Get the "property names" that may be used in a query.
    
    Returns:
    an array of "property names"
  - getPropertyTypes
```
Type[] getPropertyTypes()
```
    Get the corresponding "property types".
    
    Returns:
    an array of Hibernate types
  - getPropertyValue
```
Object getPropertyValue(Object component,
                      int property)
                        throws HibernateException
```
    Get the value of a property.
    
    Parameters:
    component - an instance of class mapped by this "type"
    property -
    
    Returns:
    the property value
    
    Throws:
    
    HibernateException
  - setPropertyValue
```
void setPropertyValue(Object component,
                    int property,
                    Object value)
                      throws HibernateException
```
    Set the value of a property.
    
    Parameters:
    component - an instance of class mapped by this "type"
    property -
    value - the value to set
    
    Throws:
    
    HibernateException
  - returnedClass
```
Class returnedClass()
```
    The class returned by nullSafeGet().
    
    Returns:
    Class
  - equals
```
boolean equals(Object x,
             Object y)
               throws HibernateException
```
    Compare two instances of the class mapped by this type for persistence "equality". Equality of the persistent state.
    
    Parameters:
    x -
    y -
    
    Returns:
    boolean
    
    Throws:
    
    HibernateException
  - hashCode
```
int hashCode(Object x)
             throws HibernateException
```
    Get a hashcode for the instance, consistent with persistence "equality"
    
    Throws:
    
    HibernateException
  - nullSafeGet
```
Object nullSafeGet(ResultSet rs,
                 String[] names,
                 SessionImplementor session,
                 Object owner)
                   throws HibernateException,
                          SQLException
```
    Retrieve an instance of the mapped class from a JDBC resultset. Implementors should handle possibility of null values.
    
    Parameters:
    rs - a JDBC result set
    names - the column names
    session -
    owner - the containing entity
    
    Returns:
    Object
    
    Throws:
    
    HibernateException
    
    SQLException
  - nullSafeSet
```
void nullSafeSet(PreparedStatement st,
               Object value,
               int index,
               SessionImplementor session)
                 throws HibernateException,
                        SQLException
```
    Write an instance of the mapped class to a prepared statement. Implementors should handle possibility of null values. A multi-column type should be written to parameters starting from index.
    
    Parameters:
    st - a JDBC prepared statement
    value - the object to write
    index - statement parameter index
    session -
    
    Throws:
    
    HibernateException
    
    SQLException
  - deepCopy
```
Object deepCopy(Object value)
                throws HibernateException
```
    Return a deep copy of the persistent state, stopping at entities and at collections.
    
    Parameters:
    value - generally a collection element or entity field
    
    Returns:
    Object a copy
    
    Throws:
    
    HibernateException
  - isMutable
```
boolean isMutable()
```
    Check if objects of this type mutable.
    
    Returns:
    boolean
  - disassemble
```
Serializable disassemble(Object value,
                       SessionImplementor session)
                         throws HibernateException
```
    Transform the object into its cacheable representation. At the very least this method should perform a deep copy. That may not be enough for some implementations, however; for example, associations must be cached as identifier values. (optional operation)
    
    Parameters:
    value - the object to be cached
    session -
    
    Returns:
    a cachable representation of the object
    
    Throws:
    
    HibernateException
  - assemble
```
Object assemble(Serializable cached,
              SessionImplementor session,
              Object owner)
                throws HibernateException
```
    Reconstruct an object from the cacheable representation. At the very least this method should perform a deep copy. (optional operation)
    
    Parameters:
    cached - the object to be cached
    session -
    owner - the owner of the cached object
    
    Returns:
    a reconstructed object from the cachable representation
    
    Throws:
    
    HibernateException
  - replace
```
Object replace(Object original,
             Object target,
             SessionImplementor session,
             Object owner)
               throws HibernateException
```
    During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. For immutable objects, or null values, it is safe to simply return the first parameter. For mutable objects, it is safe to return a copy of the first parameter. However, since composite user types often define component values, it might make sense to recursively replace component values in the target object.
    
    Parameters:
    original -
    target -
    session -
    owner -
    
    Returns:
    
    Throws:
    
    HibernateException

Interface CompositeUserType

Method Summary

Method Detail

getPropertyNames

getPropertyTypes

getPropertyValue

setPropertyValue

returnedClass

equals

hashCode

nullSafeGet

nullSafeSet

deepCopy

isMutable

disassemble

assemble

replace