/*

  * 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);

     }

   }

 }