public static GroovyAwareJavassistProxyFactory buildProxyFactory(PersistentClass persistentClass) 
{
        GroovyAwareJavassistProxyFactory proxyFactory = new GroovyAwareJavassistProxyFactory();
        Set< Class > proxyInterfaces = new HashSet< Class >() {{
            add(HibernateProxy.class);
          }
        };
        final Class javaClass = persistentClass.getMappedClass();
        final Property identifierProperty = persistentClass.getIdentifierProperty();
        final Getter idGetter = identifierProperty!=null?  identifierProperty.getGetter(javaClass) : null;
        final Setter idSetter =identifierProperty!=null? identifierProperty.getSetter(javaClass) : null;
        if(idGetter == null ||  idSetter==null) return null;
        try {
            proxyFactory.postInstantiate(persistentClass.getEntityName(),
                                    javaClass,
                                     proxyInterfaces,
                                     idGetter.getMethod(),
                                     idSetter.getMethod(),
                                     persistentClass.hasEmbeddedIdentifier() ?
                                                 (AbstractComponentType) persistentClass.getIdentifier().getType() :
                                                        null
                                            );
        }
        catch (HibernateException e) {
            LOG.warn("Cannot instantiate proxy factory: " + e.getMessage());
            return null;
        }
        return proxyFactory;
}

 public static  void cacheCriteriaByMapping(Class targetClass,
    Criteria criteria) 
{
        Mapping m = GrailsDomainBinder.getMapping(targetClass);
        if(m!=null && m.getCache()!=null) {
            if(m.getCache().getEnabled()) {
                criteria.setCacheable(true);
            }
        }
}

Configures the criteria instance to cache based on the configured mapping

 public static  void configureHibernateDomainClasses(SessionFactory sessionFactory,
    GrailsApplication application) 
{
        Map hibernateDomainClassMap = new HashMap();
        for (Object o : sessionFactory.getAllClassMetadata().values()) {
            ClassMetadata classMetadata = (ClassMetadata) o;
            configureDomainClass(sessionFactory, application, classMetadata, classMetadata.getMappedClass(EntityMode.POJO), hibernateDomainClassMap);
        }
        configureInheritanceMappings(hibernateDomainClassMap);
}

 public static  void configureInheritanceMappings(Map hibernateDomainClassMap) 
{
        // now get through all domainclasses, and add all subclasses to root class
        for (Object o : hibernateDomainClassMap.values()) {
            GrailsDomainClass baseClass = (GrailsDomainClass) o;
            if (!baseClass.isRoot()) {
                Class superClass = baseClass
                        .getClazz().getSuperclass();
                while (!superClass.equals(Object.class) && !superClass.equals(GroovyObject.class)) {
                    GrailsDomainClass gdc = (GrailsDomainClass) hibernateDomainClassMap.get(superClass.getName());
                    if (gdc == null || gdc.getSubClasses() == null) {
                        LOG.debug("did not find superclass names when mapping inheritance....");
                        break;
                    }
                    gdc.getSubClasses().add(baseClass);
                    superClass = superClass.getSuperclass();
                }
            }
        }
}

 public static HibernateProxy getAssociationProxy(Object obj,
    String associationName) 
{
        try {
            Object proxy = PropertyUtils.getProperty(obj, associationName);
            if(proxy instanceof HibernateProxy) return (HibernateProxy) proxy;
            else return null;
        }
        catch (IllegalAccessException e) {
            return null;
        }
        catch (InvocationTargetException e) {
            return null;
        }
        catch (NoSuchMethodException e) {
            return null;
        }
}

Returns the proxy for a given association or null if it is not proxied

 public static FetchMode getFetchMode(Object object) 
{
        String name = object != null ? object.toString() : "default";
        if(name.equalsIgnoreCase(FetchMode.JOIN.toString()) || name.equalsIgnoreCase("eager")) {
            return FetchMode.JOIN;
        }
        else if(name.equalsIgnoreCase(FetchMode.SELECT.toString()) || name.equalsIgnoreCase("lazy")) {
            return FetchMode.SELECT;
        }
        return FetchMode.DEFAULT;
}

Will retrieve the fetch mode for the specified instance other wise return the default FetchMode

 public static  void incrementVersion(Object target) 
{
        MetaClass metaClass = GroovySystem.getMetaClassRegistry().getMetaClass(target.getClass());
        if(metaClass.hasProperty(target, GrailsDomainClassProperty.VERSION)!=null) {
            Object version = metaClass.getProperty(target, GrailsDomainClassProperty.VERSION);
            if(version instanceof Long) {
                Long newVersion = (Long) version + 1;
                metaClass.setProperty(target, GrailsDomainClassProperty.VERSION, newVersion);
            }
        }
}

Increments the entities version number in order to force an update

 public static boolean isCacheQueriesByDefault() 
{
        Object o = ConfigurationHolder.getFlatConfig().get(CONFIG_PROPERTY_CACHE_QUERIES);
        return (o != null && o instanceof Boolean)?((Boolean)o).booleanValue():false;
}

 public static boolean isInitialized(Object obj,
    String associationName) 
{
        try {
            Object proxy = PropertyUtils.getProperty(obj, associationName);
            return Hibernate.isInitialized(proxy);
        }
        catch (IllegalAccessException e) {
            return false;
        }
        catch (InvocationTargetException e) {
            return false;
        }
        catch (NoSuchMethodException e) {
            return false;
        }
}

Checks whether an associated property is initialized and returns true if it is

 public static  void populateArgumentsForCriteria(Criteria c,
    Map argMap) 
{
        populateArgumentsForCriteria(null,c, argMap);
}

 public static  void populateArgumentsForCriteria(Class targetClass,
    Criteria c,
    Map argMap) 
{
       Integer maxParam = null;
        Integer offsetParam = null;
        if(argMap.containsKey(ARGUMENT_MAX)) {
            maxParam = (Integer)converter.convertIfNecessary(argMap.get(ARGUMENT_MAX),Integer.class);
        }
        if(argMap.containsKey(ARGUMENT_OFFSET)) {
            offsetParam = (Integer)converter.convertIfNecessary(argMap.get(ARGUMENT_OFFSET),Integer.class);
        }
        String orderParam = (String)argMap.get(ARGUMENT_ORDER);
        Object fetchObj = argMap.get(ARGUMENT_FETCH);
        if(fetchObj instanceof Map) {
            Map fetch = (Map)fetchObj;
            for (Object o : fetch.keySet()) {
                String associationName = (String) o;
                c.setFetchMode(associationName, getFetchMode(fetch.get(associationName)));
            }
        }
        final String sort = (String)argMap.get(ARGUMENT_SORT);
        final String order = ORDER_DESC.equalsIgnoreCase(orderParam) ? ORDER_DESC : ORDER_ASC;
        final int max = maxParam == null ? -1 : maxParam;
        final int offset = offsetParam == null ? -1 : offsetParam;
        if(max  > -1)
            c.setMaxResults(max);
        if(offset  > -1)
            c.setFirstResult(offset);
        if(GrailsClassUtils.getBooleanFromMap(ARGUMENT_CACHE, argMap)) {
            c.setCacheable(true);
        }
        if(GrailsClassUtils.getBooleanFromMap(ARGUMENT_LOCK, argMap)) {
            c.setLockMode(LockMode.UPGRADE);
        }
        else {
            if(argMap.get(ARGUMENT_CACHE) == null) {
                cacheCriteriaByMapping(targetClass, c);
            }
        }
        if(sort != null) {
            boolean ignoreCase = true;
            Object caseArg = argMap.get(ARGUMENT_IGNORE_CASE);
            if(caseArg instanceof Boolean) {
                ignoreCase = (Boolean) caseArg;
            }
            if(ORDER_DESC.equals(order)) {
                c.addOrder( ignoreCase ? Order.desc(sort).ignoreCase() : Order.desc(sort));
            }
            else {
                c.addOrder( ignoreCase ? Order.asc(sort).ignoreCase() : Order.asc(sort) );
            }
        }
        else {
            Mapping m = GrailsDomainBinder.getMapping(targetClass);
            if(m!=null&&!StringUtils.isBlank(m.getSort())) {
                if(ORDER_DESC.equalsIgnoreCase(m.getOrder())) {
                    c.addOrder(Order.desc(m.getSort()));
                }
                else {
                    c.addOrder(Order.asc(m.getSort()));
                }
            }
        }
}

 public static  void setObjectToReadWrite(Object target,
    SessionFactory sessionFactory) 
{
        HibernateTemplate template = new HibernateTemplate(sessionFactory);
        template.setExposeNativeSession(true);
        template.execute(new HibernateCallback() {
            public Object doInHibernate(Session session) throws HibernateException, SQLException {
                if(canModifyReadWriteState(session, target)) {
                    SessionImplementor sessionImpl = (SessionImplementor) session;
                    EntityEntry ee = sessionImpl.getPersistenceContext().getEntry(target);
                    if(ee != null && ee.getStatus() == Status.READ_ONLY) {
                        Object actualTarget = target;
                        if(target instanceof HibernateProxy) {
                            actualTarget = ((HibernateProxy)target).getHibernateLazyInitializer().getImplementation();
                        }
                        session.setReadOnly(actualTarget, false);
                        session.setFlushMode(FlushMode.AUTO);
                        incrementVersion(target);
                    }
                }
                return null;
            }
        });
}

Sets the target object to read-write, allowing Hibernate to dirty check it and auto-flush changes

 public static  void setObjectToReadyOnly(Object target,
    SessionFactory sessionFactory) 
{
        Session session = sessionFactory.getCurrentSession();
        if(canModifyReadWriteState(session, target)) {
             if(target instanceof HibernateProxy) {
                 target = ((HibernateProxy)target).getHibernateLazyInitializer().getImplementation();
             }
             session.setReadOnly(target, true);
             session.setFlushMode(FlushMode.MANUAL);
        }
}

Sets the target object to read-only using the given SessionFactory instance. This avoids Hibernate performing any dirty checking on the object

 public static Object unwrapProxy(HibernateProxy proxy) 
{
        LazyInitializer lazyInitializer = proxy.getHibernateLazyInitializer();
        if(lazyInitializer.isUninitialized()) {
            lazyInitializer.initialize();
        }
        return lazyInitializer.getImplementation();
}

Unwraps and initializes a HibernateProxy