Java Code Examples for org.apache.commons.lang3.ArrayUtils#EMPTY_CLASS_ARRAY

The following examples show how to use org.apache.commons.lang3.ArrayUtils#EMPTY_CLASS_ARRAY . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 6 votes vote down vote up
/**
 * <p>Invokes a method whose parameter types match exactly the parameter
 * types given.</p>
 *
 * <p>This uses reflection to invoke the method obtained from a call to
 * <code>getAccessibleMethod()</code>.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactMethod(Object object, String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Method method = getAccessibleMethod(object.getClass(), methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on object: "
                + object.getClass().getName());
    }
    return method.invoke(object, args);
}
 
Example 2
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 6 votes vote down vote up
/**
 * <p>Invokes a method whose parameter types match exactly the parameter
 * types given.</p>
 *
 * <p>This uses reflection to invoke the method obtained from a call to
 * <code>getAccessibleMethod()</code>.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactMethod(final Object object, final String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    final Method method = getAccessibleMethod(object.getClass(), methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on object: "
                + object.getClass().getName());
    }
    return method.invoke(object, args);
}
 
Example 3
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 6 votes vote down vote up
/**
 * <p>Invokes a method whose parameter types match exactly the parameter
 * types given.</p>
 *
 * <p>This uses reflection to invoke the method obtained from a call to
 * <code>getAccessibleMethod()</code>.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactMethod(Object object, String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Method method = getAccessibleMethod(object.getClass(), methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on object: "
                + object.getClass().getName());
    }
    return method.invoke(object, args);
}
 
Example 4
Source File: ConstructorUtils.java    From astor with GNU General Public License v2.0 6 votes vote down vote up
/**
 * <p>Returns new instance of <code>klazz</code> created using constructor
 * with signature <code>parameterTypes</code> and actual arguments
 * <code>args</code>.</p>
 *
 * <p>The signatures should match exactly.</p>
 *
 * @param cls the class to be constructed.
 * @param args actual argument array
 * @param parameterTypes parameter types array
 * @return new instance of <code>klazz</code>
 *
 * @throws NoSuchMethodException if matching constructor cannot be found
 * @throws IllegalAccessException thrown on the constructor's invocation
 * @throws InvocationTargetException thrown on the constructor's invocation
 * @throws InstantiationException thrown on the constructor's invocation
 * @see Constructor#newInstance
 */
public static Object invokeExactConstructor(Class<?> cls, Object[] args,
        Class<?>[] parameterTypes) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException,
        InstantiationException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Constructor<?> ctor = getAccessibleConstructor(cls, parameterTypes);
    if (null == ctor) {
        throw new NoSuchMethodException(
                "No such accessible constructor on object: "
                        + cls.getName());
    }
    return ctor.newInstance(args);
}
 
Example 5
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 6 votes vote down vote up
/**
 * <p>Invokes a named method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> object
 * would match a <code>boolean</code> primitive.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the method invoked
 * @throws IllegalAccessException if the requested method is not accessible via reflection
 */
public static Object invokeMethod(Object object, String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Method method = getMatchingAccessibleMethod(object.getClass(),
            methodName, parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on object: "
                + object.getClass().getName());
    }
    return method.invoke(object, args);
}
 
Example 6
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 6 votes vote down vote up
/**
 * <p>Invoke a method whose parameter types match exactly the parameter
 * types given.</p>
 *
 * <p>This uses reflection to invoke the method obtained from a call to
 * <code>getAccessibleMethod()</code>.</p>
 *
 * @param object invoke method on this object
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactMethod(Object object, String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Method method = getAccessibleMethod(object.getClass(), methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on object: "
                + object.getClass().getName());
    }
    return method.invoke(object, args);
}
 
Example 7
Source File: MethodUtilsTest.java    From astor with GNU General Public License v2.0 5 votes vote down vote up
public void testGetAccessibleInterfaceMethod() throws Exception {

        Class<?>[][] p = { ArrayUtils.EMPTY_CLASS_ARRAY, null };
        for (int i = 0; i < p.length; i++) {
            Method method = TestMutable.class.getMethod("getValue", p[i]);
            Method accessibleMethod = MethodUtils.getAccessibleMethod(method);
            assertNotSame(accessibleMethod, method);
            assertSame(Mutable.class, accessibleMethod.getDeclaringClass());
        }
    }
 
Example 8
Source File: MethodUtilsTest.java    From astor with GNU General Public License v2.0 5 votes vote down vote up
@Test
public void testGetAccessibleInterfaceMethod() throws Exception {
    Class<?>[][] p = { ArrayUtils.EMPTY_CLASS_ARRAY, null };
    for (Class<?>[] element : p) {
        Method method = TestMutable.class.getMethod("getValue", element);
        Method accessibleMethod = MethodUtils.getAccessibleMethod(method);
        assertNotSame(accessibleMethod, method);
        assertSame(Mutable.class, accessibleMethod.getDeclaringClass());
    }
}
 
Example 9
Source File: MethodUtilsTest.java    From astor with GNU General Public License v2.0 5 votes vote down vote up
@Test
public void testGetAccessibleInterfaceMethod() throws Exception {
    Class<?>[][] p = { ArrayUtils.EMPTY_CLASS_ARRAY, null };
    for (Class<?>[] element : p) {
        Method method = TestMutable.class.getMethod("getValue", element);
        Method accessibleMethod = MethodUtils.getAccessibleMethod(method);
        assertNotSame(accessibleMethod, method);
        assertSame(Mutable.class, accessibleMethod.getDeclaringClass());
    }
}
 
Example 10
Source File: MethodUtilsTest.java    From astor with GNU General Public License v2.0 5 votes vote down vote up
public void testGetAccessibleInterfaceMethod() throws Exception {

        Class<?>[][] p = { ArrayUtils.EMPTY_CLASS_ARRAY, null };
        for (int i = 0; i < p.length; i++) {
            Method method = TestMutable.class.getMethod("getValue", p[i]);
            Method accessibleMethod = MethodUtils.getAccessibleMethod(method);
            assertNotSame(accessibleMethod, method);
            assertSame(Mutable.class, accessibleMethod.getDeclaringClass());
        }
    }
 
Example 11
Source File: MethodUtilsTest.java    From astor with GNU General Public License v2.0 5 votes vote down vote up
public void testGetAccessibleInterfaceMethodFromDescription()
        throws Exception {
    Class<?>[][] p = { ArrayUtils.EMPTY_CLASS_ARRAY, null };
    for (int i = 0; i < p.length; i++) {
        Method accessibleMethod = MethodUtils.getAccessibleMethod(
                TestMutable.class, "getValue", p[i]);
        assertSame(Mutable.class, accessibleMethod.getDeclaringClass());
    }
}
 
Example 12
Source File: MethodUtilsTest.java    From astor with GNU General Public License v2.0 5 votes vote down vote up
@Test
public void testGetAccessibleInterfaceMethodFromDescription()
        throws Exception {
    Class<?>[][] p = { ArrayUtils.EMPTY_CLASS_ARRAY, null };
    for (Class<?>[] element : p) {
        Method accessibleMethod = MethodUtils.getAccessibleMethod(
                TestMutable.class, "getValue", element);
        assertSame(Mutable.class, accessibleMethod.getDeclaringClass());
    }
}
 
Example 13
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Invoke a named static method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
 * would match a <code>boolean</code> primitive.</p>
 *
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeStaticMethod(Class<?> cls, String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Method method = getMatchingAccessibleMethod(cls, methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on class: " + cls.getName());
    }
    return method.invoke(null, args);
}
 
Example 14
Source File: ConstructorUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Returns a new instance of the specified class choosing the right constructor
 * from the list of parameter types.</p>
 * 
 * <p>This locates and calls a constructor.
 * The constructor signature must match the parameter types by assignment compatibility.</p>
 *
 * @param <T> the type to be constructed
 * @param cls  the class to be constructed, not null
 * @param args  the array of arguments, null treated as empty
 * @param parameterTypes  the array of parameter types, null treated as empty
 * @return new instance of <code>cls</code>, not null
 *
 * @throws NoSuchMethodException if a matching constructor cannot be found
 * @throws IllegalAccessException if invocation is not permitted by security
 * @throws InvocationTargetException if an error occurs on invocation
 * @throws InstantiationException if an error occurs on instantiation
 * @see Constructor#newInstance
 */
public static <T> T invokeConstructor(Class<T> cls, Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
        InstantiationException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Constructor<T> ctor = getMatchingAccessibleConstructor(cls, parameterTypes);
    if (ctor == null) {
        throw new NoSuchMethodException(
            "No such accessible constructor on object: " + cls.getName());
    }
    return ctor.newInstance(args);
}
 
Example 15
Source File: ConstructorUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Returns new instance of <code>klazz</code> created using constructor
 * with signature <code>parameterTypes</code> and actual arguments
 * <code>args</code>.</p>
 * 
 * <p>The signatures should match exactly.</p>
 * 
 * @param cls the class to be constructed.
 * @param args actual argument array
 * @param parameterTypes parameter types array
 * @return new instance of <code>klazz</code>
 * 
 * @throws NoSuchMethodException if matching constructor cannot be found
 * @throws IllegalAccessException thrown on the constructor's invocation
 * @throws InvocationTargetException thrown on the constructor's invocation
 * @throws InstantiationException thrown on the constructor's invocation
 * @see Constructor#newInstance
 */
public static <T> T invokeExactConstructor(Class<T> cls, Object[] args,
        Class<?>[] parameterTypes) throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException, InstantiationException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    Constructor<T> ctor = getAccessibleConstructor(cls, parameterTypes);
    if (null == ctor) {
        throw new NoSuchMethodException("No such accessible constructor on object: "
                + cls.getName());
    }
    return ctor.newInstance(args);
}
 
Example 16
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Invokes a named static method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
 * would match a <code>boolean</code> primitive.</p>
 *
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeStaticMethod(Class<?> cls, String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Method method = getMatchingAccessibleMethod(cls, methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on class: " + cls.getName());
    }
    return method.invoke(null, args);
}
 
Example 17
Source File: ConstructorUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Returns new instance of <code>klazz</code> created using constructor
 * with signature <code>parameterTypes</code> and actual arguments
 * <code>args</code>.</p>
 * 
 * <p>The signatures should be assignment compatible.</p>
 * 
 * @param cls the class to be constructed.
 * @param args actual argument array
 * @param parameterTypes parameter types array
 * @return new instance of <code>klazz</code>
 * 
 * @throws NoSuchMethodException if matching constructor cannot be found
 * @throws IllegalAccessException thrown on the constructor's invocation
 * @throws InvocationTargetException thrown on the constructor's invocation
 * @throws InstantiationException thrown on the constructor's invocation
 * @see Constructor#newInstance
 */
public static <T> T invokeConstructor(Class<T> cls, Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
        InstantiationException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Constructor<T> ctor = getMatchingAccessibleConstructor(cls, parameterTypes);
    if (null == ctor) {
        throw new NoSuchMethodException("No such accessible constructor on object: "
                + cls.getName());
    }
    return ctor.newInstance(args);
}
 
Example 18
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Invokes a static method whose parameter types match exactly the parameter
 * types given.</p>
 *
 * <p>This uses reflection to invoke the method obtained from a call to
 * {@link #getAccessibleMethod(Class, String, Class[])}.</p>
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeExactStaticMethod(final Class<?> cls, final String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    final Method method = getAccessibleMethod(cls, methodName, parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on class: " + cls.getName());
    }
    return method.invoke(null, args);
}
 
Example 19
Source File: MethodUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Invokes a named static method whose parameter type matches the object type.</p>
 *
 * <p>This method delegates the method search to {@link #getMatchingAccessibleMethod(Class, String, Class[])}.</p>
 *
 * <p>This method supports calls to methods taking primitive parameters 
 * via passing in wrapping classes. So, for example, a <code>Boolean</code> class
 * would match a <code>boolean</code> primitive.</p>
 *
 *
 * @param cls invoke static method on this class
 * @param methodName get method with this name
 * @param args use these arguments - treat null as empty array
 * @param parameterTypes match these parameters - treat null as empty array
 * @return The value returned by the invoked method
 *
 * @throws NoSuchMethodException if there is no such accessible method
 * @throws InvocationTargetException wraps an exception thrown by the
 *  method invoked
 * @throws IllegalAccessException if the requested method is not accessible
 *  via reflection
 */
public static Object invokeStaticMethod(Class<?> cls, String methodName,
        Object[] args, Class<?>[] parameterTypes)
        throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException {
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    Method method = getMatchingAccessibleMethod(cls, methodName,
            parameterTypes);
    if (method == null) {
        throw new NoSuchMethodException("No such accessible method: "
                + methodName + "() on class: " + cls.getName());
    }
    return method.invoke(null, args);
}
 
Example 20
Source File: ConstructorUtils.java    From astor with GNU General Public License v2.0 4 votes vote down vote up
/**
 * <p>Returns a new instance of the specified class choosing the right constructor
 * from the list of parameter types.</p>
 *
 * <p>This locates and calls a constructor.
 * The constructor signature must match the parameter types exactly.</p>
 *
 * @param <T> the type to be constructed
 * @param cls  the class to be constructed, not null
 * @param args  the array of arguments, null treated as empty
 * @param parameterTypes  the array of parameter types, null treated as empty
 * @return new instance of <code>cls</code>, not null
 *
 * @throws NoSuchMethodException if a matching constructor cannot be found
 * @throws IllegalAccessException if invocation is not permitted by security
 * @throws InvocationTargetException if an error occurs on invocation
 * @throws InstantiationException if an error occurs on instantiation
 * @see Constructor#newInstance
 */
public static <T> T invokeExactConstructor(final Class<T> cls, Object[] args,
        Class<?>[] parameterTypes) throws NoSuchMethodException, IllegalAccessException,
        InvocationTargetException, InstantiationException {
    if (args == null) {
        args = ArrayUtils.EMPTY_OBJECT_ARRAY;
    }
    if (parameterTypes == null) {
        parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
    }
    final Constructor<T> ctor = getAccessibleConstructor(cls, parameterTypes);
    if (ctor == null) {
        throw new NoSuchMethodException(
            "No such accessible constructor on object: "+ cls.getName());
    }
    return ctor.newInstance(args);
}