## org.hibernate.type
Class TypeHelper

    java.lang.Object
      org.hibernate.type.TypeHelper

    public class TypeHelper

extends Object

Collection of convenience methods relating to operations across arrays of types...

Method Summary
`static Object[]` `assemble(Serializable[] row, Type[] types, SessionImplementor session, Object owner)` Apply the `Type.assemble(java.io.Serializable, org.hibernate.engine.spi.SessionImplementor, java.lang.Object)` operation across a series of values.
`static void` `beforeAssemble(Serializable[] row, Type[] types, SessionImplementor session)` Apply the `Type.beforeAssemble(java.io.Serializable, org.hibernate.engine.spi.SessionImplementor)` operation across a series of values.
`static void` `deepCopy(Object[] values, Type[] types, boolean[] copy, Object[] target, SessionImplementor session)` Deep copy a series of values from one array to another...
`static Serializable[]` `disassemble(Object[] row, Type[] types, boolean[] nonCacheable, SessionImplementor session, Object owner)` Apply the `Type.disassemble(java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object)` operation across a series of values.
`static int[]` `findDirty(StandardProperty[] properties, Object[] currentState, Object[] previousState, boolean[][] includeColumns, boolean anyUninitializedProperties, SessionImplementor session)` Determine if any of the given field values are dirty, returning an array containing indices of the dirty fields.
`static int[]` `findModified(StandardProperty[] properties, Object[] currentState, Object[] previousState, boolean[][] includeColumns, boolean anyUninitializedProperties, SessionImplementor session)` Determine if any of the given field values are modified, returning an array containing indices of the modified fields.
`static Object[]` `replace(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copyCache)` Apply the `Type.replace(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values.
`static Object[]` `replace(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)` Apply the `Type.replace(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values.

`static Object[]`

`replaceAssociations(Object[] original, Object[] target, Type[] types, SessionImplementor session, Object owner, Map copyCache, ForeignKeyDirection foreignKeyDirection)`
Apply the `Type.replace(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values, as long as the corresponding `Type` is an association.

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

Method Detail

### deepCopy

    public static void deepCopy(Object[] values,
                                Type[] types,
                                boolean[] copy,
                                Object[] target,
                                SessionImplementor session)

  Deep copy a series of values from one array to another...

  Parameters:
    `values` - The values to copy (the source)
    `types` - The value types
    `copy` - an array indicating which values to include in the copy
    `target` - The array into which to copy the values
    `session` - The originating session

### beforeAssemble

    public static void beforeAssemble(Serializable[] row,
                                      Type[] types,
                                      SessionImplementor session)

  Apply the `Type.beforeAssemble(java.io.Serializable, org.hibernate.engine.spi.SessionImplementor)` operation across a series of values.

  Parameters:
    `row` - The values
    `types` - The value types
    `session` - The originating session

### assemble

    public static Object[] assemble(Serializable[] row,
                                    Type[] types,
                                    SessionImplementor session,
                                    Object owner)

  Apply the `Type.assemble(java.io.Serializable, org.hibernate.engine.spi.SessionImplementor, java.lang.Object)` operation across a series of values.

  Parameters:
    `row` - The values
    `types` - The value types
    `session` - The originating session
    `owner` - The entity "owning" the values
  Returns:
    The assembled state

### disassemble

    public static Serializable[] disassemble(Object[] row,
                                             Type[] types,
                                             boolean[] nonCacheable,
                                             SessionImplementor session,
                                             Object owner)

  Apply the `Type.disassemble(java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object)` operation across a series of values.

  Parameters:
    `row` - The values
    `types` - The value types
    `nonCacheable` - An array indicating which values to include in the disassembled state
    `session` - The originating session
    `owner` - The entity "owning" the values
  Returns:
    The disassembled state

### replace

    public static Object[] replace(Object[] original,
                                   Object[] target,
                                   Type[] types,
                                   SessionImplementor session,
                                   Object owner,
                                   Map copyCache)

  Apply the `Type.replace(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values.

  Parameters:
    `original` - The source of the state
    `target` - The target into which to replace the source values.
    `types` - The value types
    `session` - The originating session
    `owner` - The entity "owning" the values
    `copyCache` - A map representing a cache of already replaced state
  Returns:
    The replaced state

### replace

    public static Object[] replace(Object[] original,
                                   Object[] target,
                                   Type[] types,
                                   SessionImplementor session,
                                   Object owner,
                                   Map copyCache,
                                   ForeignKeyDirection foreignKeyDirection)

  Apply the `Type.replace(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values.

  Parameters:
    `original` - The source of the state
    `target` - The target into which to replace the source values.
    `types` - The value types
    `session` - The originating session
    `owner` - The entity "owning" the values
    `copyCache` - A map representing a cache of already replaced state
    `foreignKeyDirection` - FK directionality to be applied to the replacement
  Returns:
    The replaced state

### replaceAssociations

    public static Object[] replaceAssociations(Object[] original,
                                               Object[] target,
                                               Type[] types,
                                               SessionImplementor session,
                                               Object owner,
                                               Map copyCache,
                                               ForeignKeyDirection foreignKeyDirection)

  Apply the `Type.replace(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object, java.util.Map)` operation across a series of values, as long as the corresponding `Type` is an association.

  If the corresponding type is a component type, then apply `Type.replace(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SessionImplementor, java.lang.Object, java.util.Map)` across the component subtypes but do not replace the component value itself.

  Parameters:
    `original` - The source of the state
    `target` - The target into which to replace the source values.
    `types` - The value types
    `session` - The originating session
    `owner` - The entity "owning" the values
    `copyCache` - A map representing a cache of already replaced state
    `foreignKeyDirection` - FK directionality to be applied to the replacement
  Returns:
    The replaced state

### findDirty

    public static int[] findDirty(StandardProperty[] properties,
                                  Object[] currentState,
                                  Object[] previousState,
                                  boolean[][] includeColumns,
                                  boolean anyUninitializedProperties,
                                  SessionImplementor session)

  Determine if any of the given field values are dirty, returning an array containing indices of the dirty fields.

  If it is determined that no fields are dirty, null is returned.

  Parameters:
    `properties` - The property definitions
    `currentState` - The current state of the entity
    `previousState` - The baseline state of the entity
    `includeColumns` - Columns to be included in the dirty checking, per property
    `anyUninitializedProperties` - Does the entity currently hold any uninitialized property values?
    `session` - The session from which the dirty check request originated.
  Returns:
    Array containing indices of the dirty properties, or null if no properties considered dirty.

### findModified

    public static int[] findModified(StandardProperty[] properties,
                                     Object[] currentState,
                                     Object[] previousState,
                                     boolean[][] includeColumns,
                                     boolean anyUninitializedProperties,
                                     SessionImplementor session)

  Determine if any of the given field values are modified, returning an array containing indices of the modified fields.

  If it is determined that no fields are dirty, null is returned.

  Parameters:
    `properties` - The property definitions
    `currentState` - The current state of the entity
    `previousState` - The baseline state of the entity
    `includeColumns` - Columns to be included in the mod checking, per property
    `anyUninitializedProperties` - Does the entity currently hold any uninitialized property values?
    `session` - The session from which the dirty check request originated.
  Returns:
    Array containing indices of the modified properties, or null if no properties considered modified.

Copyright © 2001-2012 Red Hat, Inc. All Rights Reserved.