Open Source Repository

Home /hibernate/hibernate-3.2.4.ga | Repository Home


org/hibernate/intercept/javassist/FieldInterceptorImpl.java
//$Id: FieldInterceptorImpl.java 10209 2006-08-03 20:35:26Z [email protected] $
package org.hibernate.intercept.javassist;

import java.io.Serializable;
import java.util.Set;

import org.hibernate.bytecode.javassist.FieldHandler;
import org.hibernate.intercept.AbstractFieldInterceptor;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.proxy.HibernateProxy;
import org.hibernate.proxy.LazyInitializer;

/**
 * A field-level interceptor that initializes lazily fetched properties.
 * This interceptor can be attached to classes instrumented by Javassist.
 * Note that this implementation assumes that the instance variable
 * name is the same as the name of the persistent property that must
 * be loaded.
 </p>
 * Note: most of the interesting functionality here is farmed off
 * to the super-class.  The stuff here mainly acts as an adapter to the
 * Javassist-specific functionality, routing interception through
 * the super-class's intercept() method
 *
 @author Steve Ebersole
 */
public final class FieldInterceptorImpl extends AbstractFieldInterceptor implements FieldHandler, Serializable {

  /**
   * Package-protected constructor.
   *
   @param session
   @param uninitializedFields
   @param entityName
   */
  FieldInterceptorImpl(SessionImplementor session, Set uninitializedFields, String entityName) {
    supersession, uninitializedFields, entityName );
  }


  // FieldHandler impl ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

  public boolean readBoolean(Object target, String name, boolean oldValue) {
    return ( ( Boolean intercepttarget, name, oldValue  ? Boolean.TRUE : Boolean.FALSE ) )
        .booleanValue();
  }

  public byte readByte(Object target, String name, byte oldValue) {
    return ( ( Byte intercepttarget, name, new ByteoldValue ) ) ).byteValue();
  }

  public char readChar(Object target, String name, char oldValue) {
    return ( ( Character intercepttarget, name, new CharacteroldValue ) ) )
        .charValue();
  }

  public double readDouble(Object target, String name, double oldValue) {
    return ( ( Double intercepttarget, name, new DoubleoldValue ) ) )
        .doubleValue();
  }

  public float readFloat(Object target, String name, float oldValue) {
    return ( ( Float intercepttarget, name, new FloatoldValue ) ) )
        .floatValue();
  }

  public int readInt(Object target, String name, int oldValue) {
    return ( ( Integer intercepttarget, name, new IntegeroldValue ) ) )
        .intValue();
  }

  public long readLong(Object target, String name, long oldValue) {
    return ( ( Long intercepttarget, name, new LongoldValue ) ) ).longValue();
  }

  public short readShort(Object target, String name, short oldValue) {
    return ( ( Short intercepttarget, name, new ShortoldValue ) ) )
        .shortValue();
  }

  public Object readObject(Object target, String name, Object oldValue) {
    Object value = intercepttarget, name, oldValue );
    if (value instanceof HibernateProxy) {
      LazyInitializer li = ( (HibernateProxyvalue ).getHibernateLazyInitializer();
      if li.isUnwrap() ) {
        value = li.getImplementation();
      }
    }
    return value;
  }

  public boolean writeBoolean(Object target, String name, boolean oldValue, boolean newValue) {
    dirty();
    intercepttarget, name, oldValue ? Boolean.TRUE : Boolean.FALSE );
    return newValue;
  }

  public byte writeByte(Object target, String name, byte oldValue, byte newValue) {
    dirty();
    intercepttarget, name, new ByteoldValue ) );
    return newValue;
  }

  public char writeChar(Object target, String name, char oldValue, char newValue) {
    dirty();
    intercepttarget, name, new CharacteroldValue ) );
    return newValue;
  }

  public double writeDouble(Object target, String name, double oldValue, double newValue) {
    dirty();
    intercepttarget, name, new DoubleoldValue ) );
    return newValue;
  }

  public float writeFloat(Object target, String name, float oldValue, float newValue) {
    dirty();
    intercepttarget, name, new FloatoldValue ) );
    return newValue;
  }

  public int writeInt(Object target, String name, int oldValue, int newValue) {
    dirty();
    intercepttarget, name, new IntegeroldValue ) );
    return newValue;
  }

  public long writeLong(Object target, String name, long oldValue, long newValue) {
    dirty();
    intercepttarget, name, new LongoldValue ) );
    return newValue;
  }

  public short writeShort(Object target, String name, short oldValue, short newValue) {
    dirty();
    intercepttarget, name, new ShortoldValue ) );
    return newValue;
  }

  public Object writeObject(Object target, String name, Object oldValue, Object newValue) {
    dirty();
    intercepttarget, name, oldValue );
    return newValue;
  }

  public String toString() {
    return "FieldInterceptorImpl(" +
      "entityName=" + getEntityName() +
      ",dirty=" + isDirty() +
      ",uninitializedFields=" + getUninitializedFields() +
      ')';
  }

}