giraph-core/src/main/java/org/apache/giraph/utils/ReflectionUtils.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.giraph.utils;

import java.lang.reflect.Modifier;

import org.apache.giraph.conf.ContextSettable;
import org.apache.giraph.conf.ImmutableClassesGiraphConfiguration;
import org.apache.hadoop.mapreduce.Mapper;
import org.jodah.typetools.TypeResolver;

/**
 * Helper methods to get type arguments to generic classes.  Courtesy of
 * Ian Robertson (overstock.com).  Make sure to use with abstract
 * generic classes, not interfaces.
 */
public class ReflectionUtils {
  /**
   * Do not instantiate.
   */
  private ReflectionUtils() { }

  /**
   * Get package path to the object given. Used with resources.
   *
   * @param object the Object to check
   * @return Path to package of object
   */
  public static String getPackagePath(Object object) {
    return getPackagePath(object.getClass());
  }

  /**
   * Get package path to the class given. Used with resources.
   *
   * @param klass Class to check
   * @return Path to package of class
   */
  public static String getPackagePath(Class klass) {
    return klass.getPackage().getName().replaceAll("\\.", "/");
  }

  /**
   * Get the actual type arguments a child class has used to extend a
   * generic base class.
   *
   * @param <T> Type to evaluate.
   * @param baseClass the base class
   * @param childClass the child class
   * @return a list of the raw classes for the actual type arguments.
   */
  public static <T> Class<?>[] getTypeArguments(
      Class<T> baseClass, Class<? extends T> childClass) {
    return TypeResolver.resolveArguments(childClass, baseClass);
  }

  /**
   * Instantiate a class, wrap exceptions
   *
   * @param theClass Class to instantiate
   * @param <T> Type to instantiate
   * @return Newly instantiated object
   */
  @SuppressWarnings("unchecked")
  public static <T> T newInstance(Class<T> theClass) {
    try {
      return theClass.newInstance();
    } catch (InstantiationException e) {
      throw new IllegalStateException(
          "newInstance: Couldn't instantiate " + theClass.getName(), e);
    } catch (IllegalAccessException e) {
      throw new IllegalStateException(
          "newInstance: Illegal access " + theClass.getName(), e);
    }
  }

  /**
   * Instantiate classes that are ImmutableClassesGiraphConfigurable
   *
   * @param theClass Class to instantiate
   * @param configuration Giraph configuration, may be null
   * @param <T> Type to instantiate
   * @return Newly instantiated object with configuration set if possible
   */
  @SuppressWarnings("unchecked")
  public static <T> T newInstance(
      Class<T> theClass,
      ImmutableClassesGiraphConfiguration configuration) {
    T result;
    try {
      result = theClass.newInstance();
    } catch (InstantiationException e) {
      throw new IllegalStateException(
          "newInstance: Couldn't instantiate " + theClass.getName(), e);
    } catch (IllegalAccessException e) {
      throw new IllegalStateException(
          "newInstance: Illegal access " + theClass.getName(), e);
    }
    ConfigurationUtils.configureIfPossible(result, configuration);
    return result;
  }

  /**
   * Instantiate classes that are ImmutableClassesGiraphConfigurable,
   * and optionally set context on them if they are ContextSettable
   *
   * @param theClass Class to instantiate
   * @param configuration Giraph configuration, may be null
   * @param context Mapper context
   * @param <T> Type to instantiate
   * @return Newly instantiated object with configuration and context set if
   * possible
   */
  public static <T> T newInstance(
      Class<T> theClass,
      ImmutableClassesGiraphConfiguration configuration,
      Mapper<?, ?, ?, ?>.Context context) {
    T result = newInstance(theClass, configuration);
    if (result instanceof ContextSettable) {
      ((ContextSettable) result).setContext(context);
    }
    return result;
  }

  /**
   * Verify that found type matches the expected type. If types don't match an
   * {@link IllegalStateException} will be thrown.
   *
   * @param concreteChild Concrete child type
   * @param parent Parent type
   * @param typeDesc String description of the type (for exception description)
   * @param mainClass Class in which the actual type was found (for exception
   *                  description)
   */
  public static void verifyTypes(Class<?> concreteChild, Class<?> parent,
      String typeDesc, Class<?> mainClass) {
    // unknown means object
    if (parent == TypeResolver.Unknown.class) {
      parent = Object.class;
    }

    verifyConcrete(concreteChild, typeDesc);

    if (!parent.isAssignableFrom(concreteChild)) {
      throw new IllegalStateException("verifyTypes: " + typeDesc + " types " +
          "don't match, in " + mainClass.getName() + " " + concreteChild +
          " expected, but " + parent + " found");
    }
  }

  /**
   * Verify that given type is a concrete type that can be instantiated.
   *
   * @param concrete type to check
   * @param typeDesc String description of the type (for exception description)
   */
  public static void verifyConcrete(
      Class<?> concrete, String typeDesc) {
    if (concrete.isInterface()) {
      throw new IllegalStateException("verifyTypes: " +
          "Type " + typeDesc + " must be concrete class " + concrete);
    }
    if (Modifier.isAbstract(concrete.getModifiers())) {
      throw new IllegalStateException("verifyTypes: " +
          "Type " + typeDesc + "can't be abstract class" + concrete);
    }
  }
}