public static CollectionType array(String role,
    String propertyRef,
    boolean embedded,
    Class elementClass) 
{
		return new ArrayType( role, propertyRef, elementClass, embedded );
}

 public static Object[] assemble(Serializable[] row,
    Type[] types,
    SessionImplementor session,
    Object owner) throws HibernateException 
{
		Object[] assembled = new Object[row.length];
		for ( int i = 0; i <  types.length; i++ ) {
			if ( row[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
				|| row[i] == BackrefPropertyAccessor.UNKNOWN ) {
				assembled[i] = row[i];
			}
			else {
				assembled[i] = types[i].assemble( row[i], session, owner );
			}
		}
		return assembled;
}

 public static CollectionType bag(String role,
    String propertyRef,
    boolean embedded) 
{
		return new BagType( role, propertyRef, embedded );
}

 public static Type basic(String name) 
{
		return (Type) BASIC_TYPES.get( name );
}

Given the name of a Hibernate basic type, return an instance of org.hibernate.type.Type.

 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 );
			}
		}
}

Determine if any of the given field values are modified, returning an array containing indexes of the dirty fields or null if no fields are dirty.

 public static CollectionType customCollection(String typeName,
    String role,
    String propertyRef,
    boolean embedded) 
{
		Class typeClass;
		try {
			typeClass = ReflectHelper.classForName( typeName );
		}
		catch (ClassNotFoundException cnfe) {
			throw new MappingException( "user colllection type class not found: " + typeName, cnfe );
		}
		return new CustomCollectionType( typeClass, role, propertyRef, embedded );
}

 public static  void deepCopy(Object[] values,
    Type[] types,
    boolean[] copy,
    Object[] target,
    SessionImplementor session) throws HibernateException 
{
		for ( int i = 0; i <  types.length; i++ ) {
			if ( copy[i] ) {
				if ( values[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
					|| values[i] == BackrefPropertyAccessor.UNKNOWN ) {
					target[i] = values[i];
				}
				else {
					target[i] = types[i].deepCopy( values[i], session.getEntityMode(), session
						.getFactory() );
				}
			}
		}
}

Deep copy values in the first array into the second

 public static Serializable[] disassemble(Object[] row,
    Type[] types,
    boolean[] nonCacheable,
    SessionImplementor session,
    Object owner) throws HibernateException 
{
		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 ) {
				disassembled[i] = (Serializable) row[i];
			}
			else {
				disassembled[i] = types[i].disassemble( row[i], session, owner );
			}
		}
		return disassembled;
}

 public static int[] findDirty(StandardProperty[] properties,
    Object[] x,
    Object[] y,
    boolean[][] includeColumns,
    boolean anyUninitializedProperties,
    SessionImplementor session) throws HibernateException 
{
		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 );
			if ( dirty ) {
				if ( results == null ) {
					results = new int[span];
				}
				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 dirty, returning an array containing indexes of the dirty fields or null if no fields are dirty.

 public static int[] findModified(StandardProperty[] properties,
    Object[] x,
    Object[] y,
    boolean[][] includeColumns,
    boolean anyUninitializedProperties,
    SessionImplementor session) throws HibernateException 
{
		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
					&& properties[i].isDirtyCheckable(anyUninitializedProperties)
					&& properties[i].getType().isModified( y[i], x[i], includeColumns[i], session );
			if ( modified ) {
				if ( results == null ) {
					results = new int[span];
				}
				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 null if no fields are dirty.

 public static Type heuristicType(String typeName) throws MappingException 
{
		return heuristicType( typeName, null );
}

Uses heuristics to deduce a Hibernate type given a string naming the type or Java class. Return an instance of org.hibernate.type.Type.

 public static Type heuristicType(String typeName,
    Properties parameters) throws MappingException 
{
		Type type = TypeFactory.basic( typeName );
		if ( type == null ) {
			Class typeClass;
			try {
				typeClass = ReflectHelper.classForName( typeName );
			}
			catch (ClassNotFoundException cnfe) {
				typeClass = null;
			}
			if ( typeClass != null ) {
				if ( Type.class.isAssignableFrom( typeClass ) ) {
					try {
						type = (Type) typeClass.newInstance();
					}
					catch (Exception e) {
						throw new MappingException( 
								"Could not instantiate Type: " + typeClass.getName(),
								e 
							);
					}
					injectParameters(type, parameters);
				}
				else if ( CompositeUserType.class.isAssignableFrom( typeClass ) ) {
					type = new CompositeCustomType( typeClass, parameters );
				}
				else if ( UserType.class.isAssignableFrom( typeClass ) ) {
					type = new CustomType( typeClass, parameters );
				}
				else if ( Lifecycle.class.isAssignableFrom( typeClass ) ) {
					type = Hibernate.entity( typeClass );
				}
				else if ( Serializable.class.isAssignableFrom( typeClass ) ) {
					type = Hibernate.serializable( typeClass );
				}
			}
		}
		return type;
}

Uses heuristics to deduce a Hibernate type given a string naming the type or Java class. Return an instance of org.hibernate.type.Type.

 public static CollectionType idbag(String role,
    String propertyRef,
    boolean embedded) 
{
		return new IdentifierBagType( role, propertyRef, 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()
				);
		}
}

 public static CollectionType list(String role,
    String propertyRef,
    boolean embedded) 
{
		return new ListType( role, propertyRef, embedded );
}

 public static EntityType manyToOne(String persistentClass) 
{
		return new ManyToOneType( persistentClass );
}

A many-to-one association type for the given class

 public static EntityType manyToOne(String persistentClass,
    boolean lazy) 
{
		return new ManyToOneType( persistentClass, lazy );
}

A many-to-one association type for the given class

 public static EntityType manyToOne(String persistentClass,
    String uniqueKeyPropertyName,
    boolean lazy,
    boolean unwrapProxy,
    boolean isEmbeddedInXML,
    boolean ignoreNotFound) 
{
		return new ManyToOneType( 
				persistentClass, 
				uniqueKeyPropertyName, 
				lazy,
				unwrapProxy, 
				isEmbeddedInXML,
				ignoreNotFound
			);
}

A many-to-one association type for the given class

 public static CollectionType map(String role,
    String propertyRef,
    boolean embedded) 
{
		return new MapType( role, propertyRef, embedded );
}

 public static EntityType oneToOne(String persistentClass,
    ForeignKeyDirection foreignKeyType,
    String uniqueKeyPropertyName,
    boolean lazy,
    boolean unwrapProxy,
    boolean isEmbeddedInXML,
    String entityName,
    String propertyName) 
{
		return new OneToOneType(
				persistentClass,
				foreignKeyType,
				uniqueKeyPropertyName,
				lazy,
				unwrapProxy,
				isEmbeddedInXML,
				entityName,
				propertyName 
			);
}

A one-to-one association type for the given class

 public static CollectionType orderedMap(String role,
    String propertyRef,
    boolean embedded) 
{
		return new OrderedMapType( role, propertyRef, embedded );
}

 public static CollectionType orderedSet(String role,
    String propertyRef,
    boolean embedded) 
{
		return new OrderedSetType( role, propertyRef, embedded );
}

 public static Object[] replace(Object[] original,
    Object[] target,
    Type[] types,
    SessionImplementor session,
    Object owner,
    Map copyCache) throws HibernateException 
{
		Object[] copied = new Object[original.length];
		for ( int i = 0; i <  types.length; i++ ) {
			if ( original[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
				|| original[i] == BackrefPropertyAccessor.UNKNOWN ) {
				copied[i] = target[i];
			}
			else {
				copied[i] = types[i].replace( original[i], target[i], session, owner, copyCache );
			}
		}
		return copied;
}

 public static Object[] replace(Object[] original,
    Object[] target,
    Type[] types,
    SessionImplementor session,
    Object owner,
    Map copyCache,
    ForeignKeyDirection foreignKeyDirection) throws HibernateException 
{
		Object[] copied = new Object[original.length];
		for ( int i = 0; i <  types.length; i++ ) {
			if ( original[i] == LazyPropertyInitializer.UNFETCHED_PROPERTY
				|| original[i] == BackrefPropertyAccessor.UNKNOWN ) {
				copied[i] = target[i];
			}
			else {
				copied[i] = types[i].replace( original[i], target[i], session, owner, copyCache, foreignKeyDirection );
			}
		}
		return copied;
}

 public static CollectionType set(String role,
    String propertyRef,
    boolean embedded) 
{
		return new SetType( role, propertyRef, embedded );
}

 public static CollectionType sortedMap(String role,
    String propertyRef,
    boolean embedded,
    Comparator comparator) 
{
		return new SortedMapType( role, propertyRef, comparator, embedded );
}

 public static CollectionType sortedSet(String role,
    String propertyRef,
    boolean embedded,
    Comparator comparator) 
{
		return new SortedSetType( role, propertyRef, comparator, embedded );
}