AbstractPersistenceProvider.java

package org.jboss.seam.persistence;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Date;

import javax.persistence.EntityManager;
import javax.persistence.OptimisticLockException;
import javax.transaction.Synchronization;

import org.jboss.seam.Entity;

/**
 * Provides a default implementation of PersistenceProvider methods where possible
 * 
 * Other methods must be implemented
 * 
 * @author Pete Muir
 *
 */
public abstract class AbstractPersistenceProvider
{

   /**
    *  Set the flush mode to manual-only flushing. Called when
    *  an atomic persistence context is required.
    */
   public abstract void setFlushModeManual(EntityManager entityManager);

   /**
    * Does the persistence context have unflushed changes? If
    * it does not, persistence context replication can be
    * optimized.
    * 
    * @return true to indicate that there are unflushed changes
    */
   public abstract boolean isDirty(EntityManager entityManager);

   /**
    * Get the value of the entity identifier attribute.
    * 
    * @param bean a managed entity instance
    */
   public Object getId(Object bean, EntityManager entityManager)
   {
      return Entity.forClass( bean.getClass() ).getIdentifier(bean);
   }

   /**
    * Get the name of the entity
    * 
    * @param bean
    * @param entityManager
    * 
    * @throws IllegalArgumentException if the passed object is not an entity
    */
   public String getName(Object bean, EntityManager entityManager) throws IllegalArgumentException
   {
      return Entity.forClass(bean.getClass()).getName();
   }

   /**
    * Get the value of the entity version attribute.
    * 
    * @param bean a managed entity instance
    */
   public Object getVersion(Object bean, EntityManager entityManager)
   {
      return Entity.forClass( bean.getClass() ).getVersion(bean);
   }

   public void checkVersion(Object bean, EntityManager entityManager, Object oldVersion, Object version)
   {
      boolean equal;
      if (oldVersion instanceof Date)
      {
         equal = ( (Date) oldVersion ).getTime() == ( (Date) version ).getTime();
      }
      else
      {
         equal = oldVersion.equals(version);
      }
      if ( !equal )
      {
         throw new OptimisticLockException("current database version number does not match passivated version number");
      }
   }

   /**
    * Enable a Filter. This is here just especially for Hibernate,
    * since we well know that other products don't have such cool
    * features. 
    */
   public abstract void enableFilter(Filter filter, EntityManager entityManager);

   /**
    * Register a Synchronization with the current transaction.
    */
   public abstract boolean registerSynchronization(Synchronization sync, EntityManager entityManager);

   /**
    * Wrap the delegate before returning it to the application
    */
   public Object proxyDelegate(Object delegate)
   {
      return delegate;
   }

   /**
    * Wrap the entityManager before returning it to the application
    */
   public EntityManager proxyEntityManager(EntityManager entityManager)
   {
      return (EntityManager) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(),
            new Class[] { EntityManagerProxy.class },
            new EntityManagerInvocationHandler(entityManager));
   }

   /**
    * Returns the class of an entity bean instance
    * 
    * @param bean The entity bean instance
    * @return The class of the entity bean
    */
   public Class getBeanClass(Object bean)
   {
      return Entity.forClass(bean.getClass()).getBeanClass();
   }

   public Method getPostLoadMethod(Class beanClass, EntityManager entityManager)
   {
      return Entity.forClass(beanClass).getPostLoadMethod();      
   }

   public Method getPrePersistMethod(Class beanClass, EntityManager entityManager)
   {
      return Entity.forClass(beanClass).getPrePersistMethod();
   }

   public Method getPreUpdateMethod(Class beanClass, EntityManager entityManager)
   {
      return Entity.forClass(beanClass).getPreUpdateMethod();
   }

   public Method getPreRemoveMethod(Class beanClass, EntityManager entityManager)
   {
      return Entity.forClass(beanClass).getPreRemoveMethod();
   }

}