org.apache.geode.internal.lang.ObjectUtils Maven / Gradle / Ivy

/*
 * 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.geode.internal.lang;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * The ObjectUtils class is an abstract utility class for working with and invoking methods on
 * Objects.
 * 
 * 
 * @see java.lang.Object
 * @since GemFire 6.8
 */
@SuppressWarnings("unused")
public abstract class ObjectUtils {

  public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];

  /**
   * Gets the first non-null value in an array of values. If the array is null, then null is
   * returned, otherwise the first non-null array element is returned. If the array is not null and
   * all the array elements are null, then null is still returned.
   * 

   * 
   * @param  a type parameter specifying the array element type.
   * @param values the array of values being iterated for the first non-null value.
   * @return the first non-null value from the array of values, otherwise return null if either the
   *         array is null or all the elements of the array are null.
   */
  public static  T defaultIfNull(T... values) {
    if (values != null) {
      for (T value : values) {
        if (value != null) {
          return value;
        }
      }
    }

    return null;
  }

  /**
   * Determines whether 2 Objects are equal in value. The Objects are equal if and only if neither
   * are null and are equal according to the equals method of the Object's class type.
   * 

   * 
   * @param obj1 the first Object in the equality comparison.
   * @param obj2 the second Object in the equality comparison.
   * @return a boolean value indicating whether the 2 Objects are equal in value.
   * @see java.lang.Object#equals(Object)
   */
  public static boolean equals(final Object obj1, final Object obj2) {
    return (obj1 != null && obj1.equals(obj2));
  }

  /**
   * Determines whether 2 Objects are equal in value by ignoring nulls. If both Object references
   * are null, then they are considered equal, or neither must be null and the Objects must be equal
   * in value as determined by their equals method.
   * 

   * 
   * @param obj1 the first Object in the equality comparison.
   * @param obj2 the second Object in the equality comparison.
   * @return a boolean value indicating whether the 2 Objects are equal in value. If both Object
   *         references are null, then they are considered equal.
   * @see java.lang.Object#equals(Object)
   */
  public static boolean equalsIgnoreNull(final Object obj1, final Object obj2) {
    return (obj1 == null ? obj2 == null : obj1.equals(obj2));
  }

  /**
   * A null-safe computation of the specified Object's hash value. If the Object reference is null,
   * then this method returns 0 and will be consistent with the equalsIgnoreNull equality
   * comparison.
   * 

   * 
   * @param obj the Object who's hash value will be computed.
   * @return an integer signifying the hash value of the Object or 0 if the Object reference is
   *         null.
   * @see java.lang.Object#hashCode()
   */
  public static int hashCode(final Object obj) {
    return (obj == null ? 0 : obj.hashCode());
  }

  /**
   * Null-safe implementation of the Object.toString method.
   * 
   * 
   * @param obj the Object on which to call toString.
   * @return the String representation of the specified Object or null if the Object reference is
   *         null.
   * @see java.lang.Object#toString()
   */
  public static String toString(final Object obj) {
    return (obj == null ? null : obj.toString());
  }

  /**
   * Gets the Class types of all arguments in the Object array.
   * 
   * 
   * @param args the Object array of arguments to determine the Class types for.
   * @return a Class array containing the Class types of each argument in the arguments Object
   *         array.
   * @see #invoke(Object, String, Object...)
   */
  static Class[] getArgumentTypes(final Object... args) {
    Class[] argTypes = null;

    if (args != null) {
      int index = 0;
      argTypes = new Class[args.length];
      for (Object arg : args) {
        argTypes[index++] = ClassUtils.getClass(arg);
      }
    }

    return argTypes;
  }

  /**
   * Invokes a method by name on the specified Object using Java Reflection.
   * 

   * 
   * @param obj the Object in which to invoke the method on.
   * @param methodName a String value indication the name of the method to invoke.
   * @param  a generic type parameter for the method return value.
   * @return a value of the method invocation on Object cast to the generized type.
   * @see #invoke(Object, String, Class[], Object...)
   */
  public static  T invoke(final Object obj, final String methodName) {
    return invoke(obj, methodName, (Class[]) null, (Object[]) null);
  }

  /**
   * Invokes a method by name on the specified Object using Java Reflection.
   * 

   * 
   * @param obj the Object in which to invoke the method on.
   * @param methodName a String value indication the name of the method to invoke.
   * @param arguments the Object arguments to the method based on its parameters.
   * @param  a generic type parameter for the method return value.
   * @return a value of the method invocation on Object cast to the generized type.
   * @see #getArgumentTypes(Object...)
   * @see #invoke(Object, String, Class[], Object...)
   */
  public static  T invoke(final Object obj, final String methodName, final Object... arguments) {
    return invoke(obj, methodName, getArgumentTypes(arguments), arguments);
  }

  /**
   * Invokes a method by name on the specified Object using Java Reflection.
   * 
   * 
   * @param obj the Object in which to invoke the method on.
   * @param methodName a String value indication the name of the method to invoke.
   * @param parameterTypes the Class types of parameters indicating the exact method to invoke
   *        (parameters in number, order and type) if the method is overloaded.
   * @param arguments the Object arguments to the method based on its parameters.
   * @param  a generic type parameter for the method return value.
   * @return a value of the method invocation on Object cast to the generized type.
   */
  @SuppressWarnings("unchecked")
  public static  T invoke(final Object obj, final String methodName,
      final Class[] parameterTypes, final Object... arguments) {
    assert obj != null : String.format("The Object to invoke method (%1$s) on cannot be null!",
        methodName);
    assert methodName != null : String.format(
        "The name of the method to invoke on Object of type (%1$s) cannot be null",
        obj.getClass().getName());

    try {
      final Method method = obj.getClass().getMethod(methodName, parameterTypes);
      method.setAccessible(true);
      return (T) method.invoke(obj, arguments);
    } catch (NoSuchMethodException e) {
      throw new RuntimeException(
          String.format("Method (%1$s) does not exist on Object of type (%2$s)!", methodName,
              obj.getClass().getName()),
          e);
    } catch (InvocationTargetException e) {
      throw new RuntimeException(
          String.format("The invocation of method (%1$s) on an Object of type (%2$s) failed!",
              methodName, obj.getClass().getName()),
          e);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(
          String.format("The method (%1$s) on an Object of type (%2$s) is not accessible!",
              methodName, obj.getClass().getName()),
          e);
    }
  }

}