[hibernate-commits] Hibernate SVN: r10757 - branches/Branch_3_2/Hibernate3/src/org/hibernate/type
hibernate-commits at lists.jboss.org
hibernate-commits at lists.jboss.org
Tue Nov 7 16:35:45 EST 2006
Author: steve.ebersole at jboss.com
Date: 2006-11-07 16:35:44 -0500 (Tue, 07 Nov 2006)
New Revision: 10757
Modified:
branches/Branch_3_2/Hibernate3/src/org/hibernate/type/TypeFactory.java
Log:
javadocs
Modified: branches/Branch_3_2/Hibernate3/src/org/hibernate/type/TypeFactory.java
===================================================================
--- branches/Branch_3_2/Hibernate3/src/org/hibernate/type/TypeFactory.java 2006-11-07 21:35:24 UTC (rev 10756)
+++ branches/Branch_3_2/Hibernate3/src/org/hibernate/type/TypeFactory.java 2006-11-07 21:35:44 UTC (rev 10757)
@@ -139,7 +139,7 @@
* A one-to-one association type for the given class
*/
public static EntityType oneToOne(
- String persistentClass,
+ String persistentClass,
ForeignKeyDirection foreignKeyType,
String uniqueKeyPropertyName,
boolean lazy,
@@ -314,11 +314,36 @@
return new SortedSetType( role, propertyRef, comparator, embedded );
}
+ public static void injectParameters(Object type, Properties parameters) {
+ if (type instanceof ParameterizedType) {
+ ( (ParameterizedType) type ).setParameterValues(parameters);
+ }
+ else if ( parameters!=null && !parameters.isEmpty() ) {
+ throw new MappingException(
+ "type is not parameterized: " +
+ type.getClass().getName()
+ );
+ }
+ }
+
+
+ // convenience methods relating to operations across arrays of types...
+
/**
- * Deep copy values in the first array into the second
+ * Deep copy a series of values from one array to another...
+ *
+ * @param values The values to copy (the source)
+ * @param types The value types
+ * @param copy an array indicating which values to include in the copy
+ * @param target The array into which to copy the values
+ * @param session The orginating session
*/
- public static void deepCopy(Object[] values, Type[] types, boolean[] copy, Object[] target,
- SessionImplementor session) throws HibernateException {
+ public static void deepCopy(
+ final Object[] values,
+ final Type[] types,
+ final boolean[] copy,
+ final Object[] target,
+ final SessionImplementor session) {
for ( int i = 0; i < types.length; i++ ) {
if ( copy[i] ) {
if ( values[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
@@ -334,57 +359,17 @@
}
/**
- * Determine if any of the given field values are dirty, returning an array containing indexes
- * of the dirty fields or <tt>null</tt> if no fields are dirty.
+ * Apply the {@link Type#beforeAssemble} operation across a series of values.
+ *
+ * @param row The values
+ * @param types The value types
+ * @param session The orginating session
*/
- /*public static int[] findDirty(Type[] types, Object[] x, Object[] y, boolean[] check,
- SessionImplementor session) throws HibernateException {
- int[] results = null;
- int count = 0;
+ public static void beforeAssemble(
+ final Serializable[] row,
+ final Type[] types,
+ final SessionImplementor session) {
for ( int i = 0; i < types.length; i++ ) {
- if ( check[i] && types[i].isDirty( x[i], y[i], session ) ) {
- if ( results == null ) results = new int[types.length];
- results[count++] = i;
- }
- }
- if ( count == 0 ) {
- return null;
- }
- else {
- int[] trimmed = new int[count];
- System.arraycopy( results, 0, trimmed, 0, count );
- return trimmed;
- }
- }*/
-
- /**
- * Determine if any of the given field values are modified, returning an array containing
- * indexes of the dirty fields or <tt>null</tt> if no fields are dirty.
- */
- /*public static int[] findModified(Type[] types, Object[] old, Object[] current, boolean[] check,
- SessionImplementor session) throws HibernateException {
- int[] results = null;
- int count = 0;
- for ( int i = 0; i < types.length; i++ ) {
- if ( check[i]
- && types[i].isModified( old[i], current[i], session ) ) {
- if ( results == null ) results = new int[types.length];
- results[count++] = i;
- }
- }
- if ( count == 0 ) {
- return null;
- }
- else {
- int[] trimmed = new int[count];
- System.arraycopy( results, 0, trimmed, 0, count );
- return trimmed;
- }
- }*/
-
- public static void beforeAssemble(Serializable[] row, Type[] types, SessionImplementor session)
- throws HibernateException {
- for ( int i = 0; i < types.length; i++ ) {
if ( row[i] != LazyPropertyInitializer.UNFETCHED_PROPERTY
&& row[i] != BackrefPropertyAccessor.UNKNOWN ) {
types[i].beforeAssemble( row[i], session );
@@ -392,12 +377,23 @@
}
}
- public static Object[] assemble(Serializable[] row, Type[] types, SessionImplementor session,
- Object owner) throws HibernateException {
+ /**
+ * Apply the {@link Type#assemble} operation across a series of values.
+ *
+ * @param row The values
+ * @param types The value types
+ * @param session The orginating session
+ * @param owner The entity "owning" the values
+ * @return The assembled state
+ */
+ public static Object[] assemble(
+ final Serializable[] row,
+ final Type[] types,
+ final SessionImplementor session,
+ final Object owner) {
Object[] assembled = new Object[row.length];
for ( int i = 0; i < types.length; i++ ) {
- if ( row[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
- || row[i] == BackrefPropertyAccessor.UNKNOWN ) {
+ if ( row[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY || row[i] == BackrefPropertyAccessor.UNKNOWN ) {
assembled[i] = row[i];
}
else {
@@ -407,15 +403,28 @@
return assembled;
}
- public static Serializable[] disassemble(Object[] row, Type[] types, boolean[] nonCacheable, SessionImplementor session,
- Object owner) throws HibernateException {
+ /**
+ * Apply the {@link Type#disassemble} operation across a series of values.
+ *
+ * @param row The values
+ * @param types The value types
+ * @param nonCacheable An array indicating which values to include in the disassemled state
+ * @param session The orginating session
+ * @param owner The entity "owning" the values
+ * @return The disassembled state
+ */
+ public static Serializable[] disassemble(
+ final Object[] row,
+ final Type[] types,
+ final boolean[] nonCacheable,
+ final SessionImplementor session,
+ final Object owner) {
Serializable[] disassembled = new Serializable[row.length];
for ( int i = 0; i < row.length; i++ ) {
if ( nonCacheable!=null && nonCacheable[i] ) {
disassembled[i] = LazyPropertyInitializer.UNFETCHED_PROPERTY;
}
- else if ( row[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
- || row[i] == BackrefPropertyAccessor.UNKNOWN ) {
+ else if ( row[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY || row[i] == BackrefPropertyAccessor.UNKNOWN ) {
disassembled[i] = (Serializable) row[i];
}
else {
@@ -425,8 +434,24 @@
return disassembled;
}
- public static Object[] replace(Object[] original, Object[] target, Type[] types,
- SessionImplementor session, Object owner, Map copyCache) throws HibernateException {
+ /**
+ * Apply the {@link Type#replace} operation across a series of values.
+ *
+ * @param original The source of the state
+ * @param target The target into which to replace the source values.
+ * @param types The value types
+ * @param session The orginating session
+ * @param owner The entity "owning" the values
+ * @param copyCache A map representing a cache of already replaced state
+ * @return The replaced state
+ */
+ public static Object[] replace(
+ final Object[] original,
+ final Object[] target,
+ final Type[] types,
+ final SessionImplementor session,
+ final Object owner,
+ final Map copyCache) {
Object[] copied = new Object[original.length];
for ( int i = 0; i < types.length; i++ ) {
if ( original[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
@@ -440,9 +465,26 @@
return copied;
}
- public static Object[] replace(Object[] original, Object[] target, Type[] types,
- SessionImplementor session, Object owner, Map copyCache,
- ForeignKeyDirection foreignKeyDirection) throws HibernateException {
+ /**
+ * Apply the {@link Type#replace} operation across a series of values.
+ *
+ * @param original The source of the state
+ * @param target The target into which to replace the source values.
+ * @param types The value types
+ * @param session The orginating session
+ * @param owner The entity "owning" the values
+ * @param copyCache A map representing a cache of already replaced state
+ * @param foreignKeyDirection FK directionality to be applied to the replacement
+ * @return The replaced state
+ */
+ public static Object[] replace(
+ final Object[] original,
+ final Object[] target,
+ final Type[] types,
+ final SessionImplementor session,
+ final Object owner,
+ final Map copyCache,
+ final ForeignKeyDirection foreignKeyDirection) {
Object[] copied = new Object[original.length];
for ( int i = 0; i < types.length; i++ ) {
if ( original[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
@@ -460,36 +502,39 @@
/**
* Determine if any of the given field values are dirty, returning an array containing
- * indexes of the dirty fields or <tt>null</tt> if no fields are dirty.
- * @param x the current state of the entity
- * @param y the snapshot state from the time the object was loaded
+ * indices of the dirty fields.
+ * <p/>
+ * If it is determined that no fields are dirty, null is returned.
+ *
+ * @param properties The property definitions
+ * @param currentState The current state of the entity
+ * @param previousState The baseline state of the entity
+ * @param includeColumns Columns to be included in the dirty checking, per property
+ * @param anyUninitializedProperties Does the entity currently hold any uninitialized property values?
+ * @param session The session from which the dirty check request originated.
+ * @return Array containing indices of the dirty properties, or null if no properties considered dirty.
*/
public static int[] findDirty(
final StandardProperty[] properties,
- final Object[] x,
- final Object[] y,
+ final Object[] currentState,
+ final Object[] previousState,
final boolean[][] includeColumns,
final boolean anyUninitializedProperties,
- final SessionImplementor session)
- throws HibernateException {
-
+ final SessionImplementor session) {
int[] results = null;
int count = 0;
int span = properties.length;
for ( int i = 0; i < span; i++ ) {
-
- final boolean dirty = x[i]!=LazyPropertyInitializer.UNFETCHED_PROPERTY //x is the "current" state
- && properties[i].isDirtyCheckable(anyUninitializedProperties)
- && properties[i].getType().isDirty( y[i], x[i], includeColumns[i], session );
-
+ final boolean dirty = currentState[i] != LazyPropertyInitializer.UNFETCHED_PROPERTY
+ && properties[i].isDirtyCheckable( anyUninitializedProperties )
+ && properties[i].getType().isDirty( previousState[i], currentState[i], includeColumns[i], session );
if ( dirty ) {
if ( results == null ) {
results = new int[span];
}
results[count++] = i;
}
-
}
if ( count == 0 ) {
@@ -504,28 +549,33 @@
/**
* Determine if any of the given field values are modified, returning an array containing
- * indexes of the dirty fields or <tt>null</tt> if no fields are dirty.
- * @param x the current state of the entity
- * @param y the snapshot state just retrieved from the database
+ * indices of the modified fields.
+ * <p/>
+ * If it is determined that no fields are dirty, null is returned.
+ *
+ * @param properties The property definitions
+ * @param currentState The current state of the entity
+ * @param previousState The baseline state of the entity
+ * @param includeColumns Columns to be included in the mod checking, per property
+ * @param anyUninitializedProperties Does the entity currently hold any uninitialized property values?
+ * @param session The session from which the dirty check request originated.
+ * @return Array containing indices of the modified properties, or null if no properties considered modified.
*/
public static int[] findModified(
final StandardProperty[] properties,
- final Object[] x,
- final Object[] y,
+ final Object[] currentState,
+ final Object[] previousState,
final boolean[][] includeColumns,
final boolean anyUninitializedProperties,
- final SessionImplementor session)
- throws HibernateException {
-
+ final SessionImplementor session) {
int[] results = null;
int count = 0;
int span = properties.length;
for ( int i = 0; i < span; i++ ) {
-
- final boolean modified = x[i]!=LazyPropertyInitializer.UNFETCHED_PROPERTY //x is the "current" state
+ final boolean modified = currentState[i]!=LazyPropertyInitializer.UNFETCHED_PROPERTY
&& properties[i].isDirtyCheckable(anyUninitializedProperties)
- && properties[i].getType().isModified( y[i], x[i], includeColumns[i], session );
+ && properties[i].getType().isModified( previousState[i], currentState[i], includeColumns[i], session );
if ( modified ) {
if ( results == null ) {
@@ -533,7 +583,6 @@
}
results[count++] = i;
}
-
}
if ( count == 0 ) {
@@ -546,16 +595,4 @@
}
}
- public static void injectParameters(Object type, Properties parameters) {
- if (type instanceof ParameterizedType) {
- ( (ParameterizedType) type ).setParameterValues(parameters);
- }
- else if ( parameters!=null && !parameters.isEmpty() ) {
- throw new MappingException(
- "type is not parameterized: " +
- type.getClass().getName()
- );
- }
- }
-
}
More information about the hibernate-commits
mailing list