BasePojomator.java

package org.pojomatic.internal;

import java.lang.invoke.CallSite;
import java.lang.invoke.ConstantCallSite;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.security.PrivilegedExceptionAction;
import java.util.Arrays;

import org.pojomatic.Pojomator;
import org.pojomatic.PropertyElement;

public abstract class BasePojomator<T> implements Pojomator<T> {
  protected final Class<?> pojoClass;
  private final ClassProperties classProperties;

  protected BasePojomator(Class<?> pojoClass, ClassProperties classProperties) {
    this.pojoClass = pojoClass;
    this.classProperties = classProperties;
  }

  @Override
  public boolean isCompatibleForEquality(Class<?> otherClass) {
    return classProperties.isCompatibleForEquals(otherClass);
  }

  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append("Pojomator for ").append(pojoClass.getName()).append(" with equals properties ");
    propertiesList(builder, classProperties.getEqualsProperties());
    builder.append(", hashCodeProperties ");
    propertiesList(builder, classProperties.getHashCodeProperties());
    builder.append(", and toStringProperties ");
    propertiesList(builder, classProperties.getToStringProperties());
    return builder.toString();
  }

  private void propertiesList(StringBuilder builder, final Iterable<PropertyElement> properties) {
    builder.append("{");
    boolean firstElement = true;
    for (PropertyElement prop: properties) {
      if (!firstElement) {
        builder.append(",");
      }
      else {
        firstElement = false;
      }
      builder.append(prop.getName());
    }
    builder.append("}");
  }

  /**
   * Construct a call site for a property accessor. Because {@code pojoClass} might not be a public class, the
   * parameter in {@code methodType} cannot be {@code pojoClass}, but instead must be just {@code Object.class}. The
   * {@code pojoClass} parameter will be stored as static field in the Pojomator class, and passed in from it's
   * bootstrap method.
   * @param caller A Lookup from the original call site.
   * @param name the name of the dynamic method. This should either be "field_&lt;fieldName&gt;" or "method_&lt;methodName&gt;".
   * @param methodType the type of the dynamic method; the return type should be the type of the aforementioned field
   *   or method
   * @param pojomatorClass the type of the pojomator class
   * @return a CallSite which invokes the method or gets the field value.
   * @throws Throwable if there are reflection issues
   */
  protected static CallSite bootstrap(
      MethodHandles.Lookup caller, String name, MethodType methodType, Class<?> pojomatorClass)
      throws Throwable {
    return new ConstantCallSite(
      MethodHandles.explicitCastArguments(
        getTypedMethod(caller, name, pojomatorClass),
        MethodType.methodType(methodType.returnType(), Object.class)));
  }

  /**
   * Compare two values of static type Object for equality. If both values are arrays, then they will be considered
   * equal iff they have the same class, and (recursively) an equal set of elements.
   * @param instanceValue the first value to compare
   * @param otherValue the second value to compare
   * @return true if {@code instanceValue} and {@code otherValue} are equal to each other.
   */
  protected static boolean areObjectValuesEqual(Object instanceValue, Object otherValue) {
    if (instanceValue == otherValue) {
      return true;
    }
    if (instanceValue == null || otherValue == null) {
      return false;
    }
    else {
      if (!instanceValue.getClass().isArray()) {
        if (!instanceValue.equals(otherValue)) {
          return false;
        }
      }
      else {
        return compareArrays(instanceValue, otherValue);
      }
    }
    return true;
  }

  /**
   * Compare two values of array type for equality. They will be considered
   * equal iff they have the same class, and (recursively) an equal set of elements.
   * @param instanceValue the first value to compare
   * @param otherValue the second value to compare
   * @return true if {@code instanceValue} and {@code otherValue} are equal to each other.
   */
  protected static boolean compareArrays(Object instanceValue, Object otherValue) {
    if (instanceValue == otherValue) {
      return true;
    }
    if (instanceValue == null || otherValue == null) {
      return false;
    }
    if (!instanceValue.getClass().equals(otherValue.getClass())) {
      return false;
    }
    final Class<?> instanceComponentClass = instanceValue.getClass().getComponentType();

    if (!instanceComponentClass.isPrimitive()) {
      return Arrays.deepEquals((Object[]) instanceValue, (Object[]) otherValue);
    }
    else { // instanceComponentClass is primitive
      if (Boolean.TYPE == instanceComponentClass) {
        return Arrays.equals((boolean[]) instanceValue, (boolean[]) otherValue);
      }
      else if (Byte.TYPE == instanceComponentClass) {
        return Arrays.equals((byte[]) instanceValue, (byte[]) otherValue);
      }
      else if (Character.TYPE == instanceComponentClass) {
        return Arrays.equals((char[]) instanceValue, (char[]) otherValue);
      }
      else if (Short.TYPE == instanceComponentClass) {
        return Arrays.equals((short[]) instanceValue, (short[]) otherValue);
      }
      else if (Integer.TYPE == instanceComponentClass) {
        return Arrays.equals((int[]) instanceValue, (int[]) otherValue);
      }
      else if (Long.TYPE == instanceComponentClass) {
        return Arrays.equals((long[]) instanceValue, (long[]) otherValue);
      }
      else if (Float.TYPE == instanceComponentClass) {
        return Arrays.equals((float[]) instanceValue, (float[]) otherValue);
      }
      else if (Double.TYPE == instanceComponentClass) {
        return Arrays.equals((double[]) instanceValue, (double[]) otherValue);
      }
      else {
        // should NEVER happen
        throw new IllegalStateException(
          "unknown primitive type " + instanceComponentClass.getName());
      }
    }
  }


  /**
   * Given an object which is of array type, compute it's hashCode by calling the appropriate signature of
   * {@link Arrays}{@code .hashCode()}
   * @param array the array
   * @param deepArray whether to do a deep hashCode for Object arrays.
   * @return the hashCode
   */
  protected static int arrayHashCode(Object array, boolean deepArray) {
    Class<?> componentType = array.getClass().getComponentType();
    if (! componentType.isPrimitive()) {
      return deepArray ? Arrays.deepHashCode((Object[]) array) : Arrays.hashCode((Object[]) array);
    }
    if (componentType == boolean.class) {
      return Arrays.hashCode((boolean[]) array);
    }
    if (componentType == byte.class) {
      return Arrays.hashCode((byte[]) array);
    }
    if (componentType == char.class) {
      return Arrays.hashCode((char[]) array);
    }
    if (componentType == short.class) {
      return Arrays.hashCode((short[]) array);
    }
    if (componentType == int.class) {
      return Arrays.hashCode((int[]) array);
    }
    if (componentType == long.class) {
      return Arrays.hashCode((long[]) array);
    }
    if (componentType == float.class) {
      return Arrays.hashCode((float[]) array);
    }
    if (componentType == double.class) {
      return Arrays.hashCode((double[]) array);
    }
    throw new IllegalStateException("unknown primitive type " + componentType.getName());
  }

  protected static <T> T checkNotNull(T reference) {
    if (reference == null) {
      throw new NullPointerException();
    }
    return reference;
  }

  protected static <T> T checkNotNull(T reference, String message) {
    if (reference == null) {
      throw new NullPointerException(message);
    }
    return reference;
  }

  protected static void checkNotNullPop(Object reference) {
    if (reference == null) {
      throw new NullPointerException();
    }
  }

  protected void checkCompatibleForEquality(T instance, String label) {
    if (!isCompatibleForEquality(instance.getClass())) {
      throw new IllegalArgumentException(
        label + " has type " + instance.getClass().getName()
        + " which is not compatible for equality with " + pojoClass.getName());
    }
  }

  /**
   * Get a method handle to access a field or invoke a no-arg method.
   * @param caller A Lookup from the original call site.
   * @param name the name of the dynamic method. This should be of the form "get_xxx", where "element_xxx" will be a
   * static field containing a {@link PropertyElement} instance referring to the property to be accessed.
   * @param pojomatorClass the type of the pojomator class
   * @return the MethodHandle
   * @throws Throwable
   */
  private static MethodHandle getTypedMethod(
    final MethodHandles.Lookup caller, final String name, final Class<?> pojomatorClass)
    throws Throwable {
    try {
      return AccessController.doPrivileged(new PrivilegedExceptionAction<MethodHandle>() {
        @Override
        public MethodHandle run() throws Exception {
          return getTypedMethodPrivileged(caller, name, pojomatorClass);
        }
      });
    } catch (PrivilegedActionException e) {
      throw e.getCause();
    }
  }

  /**
   * Do the work for {@link #getTypedMethod(java.lang.invoke.MethodHandles.Lookup, String, Class)}. This method will be
   * run inside of a {@link AccessController#doPrivileged(PrivilegedExceptionAction)} block, hence should make sure to
   * not run untrusted code.
   * @param pojomatorClass the type of the pojomator class
   * @return the MethodHandle
   * @throws NoSuchFieldException
   * @throws IllegalAccessException
   */
  private static MethodHandle getTypedMethodPrivileged(
    MethodHandles.Lookup caller, String name, Class<?> pojomatorClass)
    throws NoSuchFieldException, IllegalAccessException {
    String elementName = "element_" + name.substring(4);
    Field elementField = pojomatorClass.getDeclaredField(elementName);
    elementField.setAccessible(true);
    PropertyElement property = (PropertyElement) elementField.get(null);
    AnnotatedElement element = property.getElement();
    // Note that while element is a reference to untrusted code, we do not actually invoke this code inside a
    // doPrivileged block - we merely make it accessible to be invoked later, outside of a doPriviliged block
    if (element instanceof Field) {
      Field field = (Field) element;
      field.setAccessible(true);
      return caller.unreflectGetter(field);
    }
    else if (element instanceof Method) {
      Method method = (Method) element;
      method.setAccessible(true);
      return caller.unreflect(method);
    }
    else {
      throw new IllegalArgumentException("Cannot handle element of type " + element.getClass().getName());
    }
  }

}