@MappedSuperclass
@AccessType("property")
public abstract class GenericEntity
   implements
      Serializable
{
   protected Logger logger
      = Logger.getLogger( this.getClass().getName() );      
   
   // Object for storing uniqueness while not persisted
   private volatile Object object;
   
   // Id
   private long id = Long.MIN_VALUE;
   
   // Optimistic locking
   private int optimisticLockVersion;
   

   
   /**
    * Determines if this object has been stored in the database yet
    * 
    * @return true means not stored, false means stored
    */
   @Transient
   public boolean isTransient()
   {
      return( this.id == Long.MIN_VALUE );
   }
   
   /**
    * Returns the unique persisted identifier for this entity
    * (generated by the database after persistance).
    */
   @Id
   @Index(name="id")
   @GeneratedValue(strategy=GenerationType.SEQUENCE)
   public long getId()
   {
      return id;
   }
   public void setId(long id)
   {
      this.id = id;
   }
   
   /**
    * Get set the optimistic locking
    *
    * @see http://www.hibernate.org/hib_docs/annotations/reference/en/html/entity.html
    */
   @Version
   public int getOptimisticLockVersion()
   {
      return optimisticLockVersion;
   }
   public void setOptimisticLockVersion(int optimisticLock)
   {
      this.optimisticLockVersion = optimisticLock;
   }      

   /**
    * Equals implementation
    *
    * Based upon a technique by Gerry Power.
    *
    * It does mean that a pre-persisted object and [b]new instance[b] / retrieved object
    * will not be equal, but two new instances of the same retrieved object will always be
    * equal regardless of session or JVM. So you can freely mix and match disconnected objects
    * (even across JVMs), and you can mix and match pre-persisted and persisted objects
    * (with the same JVM), but you can't mix and match newly retrieved and disconnected objects
    * with pre-persisted objects.
    *
    * @see http://www.avaje.org/equals.html
    * @see http://forum.hibernate.org/viewtopic.php?t=928172&postdays=0&postorder=asc&start=105&sid=669abb6a5d57af5747220e08118d78b1
    */
   @Override
   public boolean equals(Object that)
      throws
         IllegalStateException
   {
      // Is entity?
      if (that instanceof GenericEntity) {
         
         // Cast and get id
         GenericEntity thatGenericEntity = (GenericEntity)that;
         long thatId = thatGenericEntity.getId();
         
         // Check if we have id and other side not, or we not and other side has, will fail
         if( ( ( this.id == Long.MIN_VALUE ) &&
              ( thatId != Long.MIN_VALUE ) ) ||
            ( ( this.id != Long.MIN_VALUE ) &&
              ( thatId == Long.MIN_VALUE ) ) ) {
         
            throw new IllegalStateException (
                  "This is using id and that is not using id (or in reverse)" );
         }
         
         // Compare objects
         return getObject().equals( thatGenericEntity.getObject() );
      }

      return false;
   }

   /**
    * HashCode implementation
    *
    * Based upon a technique by Gerry Power
    *
    * It does mean that a pre-persisted object and [b]new instance[b] / retrieved object
    * will not be equal, but two new instances of the same retrieved object will always be
    * equal regardless of session or JVM. So you can freely mix and match disconnected objects
    * (even across JVMs), and you can mix and match pre-persisted and persisted objects
    * (with the same JVM), but you can't mix and match newly retrieved and disconnected objects
    * with pre-persisted objects.
    *
    * @see http://www.avaje.org/equals.html
    * @see http://forum.hibernate.org/viewtopic.php?t=928172&postdays=0&postorder=asc&start=105&sid=669abb6a5d57af5747220e08118d78b1
    */
   @Override
   public int hashCode()
   {
      // Return the hashcode of our object
      return getObject().hashCode();
   }

   /**
    * Get the object to use when hashing
    *
    * Based upon a technique by Gerry Power
    */
   @Transient
   private Object getObject()
   {
      // Use id
      if( this.id != Long.MIN_VALUE ) {
         return new Long(this.id);
      }
      
      // Create object
      if( object == null ) {

         // Sync
         synchronized(this) {
            
            // Re-check, and create
            if( object == null ) {
               object = new Object();
            }
         }
      }

      // Use object
      return object;
   }    
}