com.gemstone.gemfire.internal.lang.ObjectUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of gemfire-core Show documentation
Show all versions of gemfire-core Show documentation
SnappyData store based off Pivotal GemFireXD
/*
* Copyright (c) 2010-2015 Pivotal Software, Inc. All rights reserved.
*
* Licensed 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. See accompanying
* LICENSE file.
*/
package com.gemstone.gemfire.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.
*
* @author John Blum
* @see java.lang.Object
* @since 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);
}
}
}