IndirectConstructor.java

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class IndirectConstructor {
    public static <T> T create(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName) {
        try {
            return createRaw(classLoader, parentClazz, childClassName);
        } catch (final InvocationTargetException ex) {
            throw new RuntimeException(ex.getTargetException());
        }
    }

    public static <T, P1> T create(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1);
        } catch (final InvocationTargetException ex) {
            throw new RuntimeException(ex.getTargetException());
        }
    }

    public static <T, P1, P2> T create(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1, c2, v2);
        } catch (final InvocationTargetException ex) {
            throw new RuntimeException(ex.getTargetException());
        }
    }

    public static <T, P1, P2, P3> T create(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3);
        } catch (final InvocationTargetException ex) {
            throw new RuntimeException(ex.getTargetException());
        }
    }

    public static <T, P1, P2, P3, P4> T create(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3,
            final Class<P4> c4,
            final P4 v4) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3, c4, v4);
        } catch (final InvocationTargetException ex) {
            throw new RuntimeException(ex.getTargetException());
        }
    }

    public static <T, E1 extends Throwable> T createEx1(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName) throws E1 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName);
    }

    public static <T, P1, E1 extends Throwable> T createEx1(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1) throws E1 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1);
    }

    public static <T, P1, P2, E1 extends Throwable> T createEx1(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2) throws E1 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2);
    }

    public static <T, P1, P2, P3, E1 extends Throwable> T createEx1(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3) throws E1 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3);
    }

    public static <T, P1, P2, P3, P4, E1 extends Throwable> T createEx1(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3,
            final Class<P4> c4,
            final P4 v4) throws E1 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3, c4, v4);
    }

    public static <T, E1 extends Throwable, E2 extends Throwable> T createEx2(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName) throws E1, E2 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName);
    }

    public static <T, P1, E1 extends Throwable, E2 extends Throwable> T createEx2(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1) throws E1, E2 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1);
    }

    public static <T, P1, P2, E1 extends Throwable, E2 extends Throwable> T createEx2(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2) throws E1, E2 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2);
    }

    public static <T, P1, P2, P3, E1 extends Throwable, E2 extends Throwable> T createEx2(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3) throws E1, E2 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3);
    }

    public static <T, P1, P2, P3, P4, E1 extends Throwable, E2 extends Throwable> T createEx2(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3,
            final Class<P4> c4,
            final P4 v4) throws E1, E2 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3, c4, v4);
    }

    public static <T, E1 extends Throwable, E2 extends Throwable, E3 extends Throwable> T createEx3(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName) throws E1, E2, E3 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName);
    }

    public static <T, P1, E1 extends Throwable, E2 extends Throwable, E3 extends Throwable> T createEx3(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1) throws E1, E2, E3 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1);
    }

    public static <T, P1, P2, E1 extends Throwable, E2 extends Throwable, E3 extends Throwable> T createEx3(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2) throws E1, E2, E3 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2);
    }

    public static <T, P1, P2, P3, E1 extends Throwable, E2 extends Throwable, E3 extends Throwable> T createEx3(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3) throws E1, E2, E3 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3);
    }

    public static <T, P1, P2, P3, P4, E1 extends Throwable, E2 extends Throwable, E3 extends Throwable> T createEx3(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3,
            final Class<P4> c4,
            final P4 v4) throws E1, E2, E3 {
        return createCheckedUnsafe(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3, c4, v4);
    }

    public static <T> T createCheckedUnsafe(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName) {
        try {
            return createRaw(classLoader, parentClazz, childClassName);
        } catch (final InvocationTargetException ex) {
            throwCheckedException(ex);
            return null;
        }
    }

    public static <T, P1> T createCheckedUnsafe(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1);
        } catch (final InvocationTargetException ex) {
            throwCheckedException(ex);
            return null;
        }
    }

    public static <T, P1, P2> T createCheckedUnsafe(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1, c2, v2);
        } catch (final InvocationTargetException ex) {
            throwCheckedException(ex);
            return null;
        }
    }

    public static <T, P1, P2, P3> T createCheckedUnsafe(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3);
        } catch (final InvocationTargetException ex) {
            throwCheckedException(ex);
            return null;
        }
    }

    public static <T, P1, P2, P3, P4> T createCheckedUnsafe(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3,
            final Class<P4> c4,
            final P4 v4) {
        try {
            return createRaw(classLoader, parentClazz, childClassName, c1, v1, c2, v2, c3, v3, c4, v4);
        } catch (final InvocationTargetException ex) {
            throwCheckedException(ex);
            return null;
        }
    }

    public static <T> T createRaw(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName) throws InvocationTargetException {
        final Class<T> clazz = lookupClass(classLoader, parentClazz, childClassName);

        final Constructor<T> constructor;
        try {
            constructor = (Constructor<T>) clazz.getDeclaredConstructor();
        } catch (final NoSuchMethodException | SecurityException ex) {
            throw new LinkageError(message(childClassName), ex);
        }

        try {
            return constructor.newInstance();
        } catch (final InstantiationException | IllegalAccessException ex) {
            throw new LinkageError(message(childClassName), ex);
        }
    }

    public static <T, P1> T createRaw(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1) throws InvocationTargetException {
        final Class<T> clazz = lookupClass(classLoader, parentClazz, childClassName);

        final Constructor<T> constructor;
        try {
            constructor = (Constructor<T>) clazz.getDeclaredConstructor(c1);
        } catch (final NoSuchMethodException | SecurityException ex) {
            throw new LinkageError(message(childClassName), ex);
        }

        try {
            return constructor.newInstance(v1);
        } catch (final InstantiationException | IllegalAccessException ex) {
            throw new LinkageError(message(childClassName), ex);
        }
    }

    public static <T, P1, P2> T createRaw(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2) throws InvocationTargetException {
        final Class<T> clazz = lookupClass(classLoader, parentClazz, childClassName);

        final Constructor<T> constructor;
        try {
            constructor = (Constructor<T>) clazz.getDeclaredConstructor(c1, c2);
        } catch (final NoSuchMethodException | SecurityException ex) {
            throw new LinkageError(message(childClassName), ex);
        }

        try {
            return constructor.newInstance(v1, v2);
        } catch (final InstantiationException | IllegalAccessException ex) {
            throw new LinkageError(message(childClassName), ex);
        }
    }

    public static <T, P1, P2, P3> T createRaw(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3) throws InvocationTargetException {
        final Class<T> clazz = lookupClass(classLoader, parentClazz, childClassName);

        final Constructor<T> constructor;
        try {
            constructor = (Constructor<T>) clazz.getDeclaredConstructor(c1, c2, c3);
        } catch (final NoSuchMethodException | SecurityException ex) {
            throw new LinkageError(message(childClassName), ex);
        }

        try {
            return constructor.newInstance(v1, v2, v3);
        } catch (final InstantiationException | IllegalAccessException ex) {
            throw new LinkageError(message(childClassName), ex);
        }
    }

    public static <T, P1, P2, P3, P4> T createRaw(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName,
            final Class<P1> c1,
            final P1 v1,
            final Class<P2> c2,
            final P2 v2,
            final Class<P3> c3,
            final P3 v3,
            final Class<P4> c4,
            final P4 v4) throws InvocationTargetException {
        final Class<T> clazz = lookupClass(classLoader, parentClazz, childClassName);

        final Constructor<T> constructor;
        try {
            constructor = (Constructor<T>) clazz.getDeclaredConstructor(c1, c2, c3, c4);
        } catch (final NoSuchMethodException | SecurityException ex) {
            throw new LinkageError(message(childClassName), ex);
        }

        try {
            return constructor.newInstance(v1, v2, v3, v4);
        } catch (final InstantiationException | IllegalAccessException ex) {
            throw new LinkageError(message(childClassName), ex);
        }
    }

    @SuppressWarnings("unchecked")
    private static <T> Class<T> lookupClass(
            final ClassLoader classLoader,
            final Class<T> parentClazz,
            final String childClassName) {
        try {
            return (Class<T>) classLoader.loadClass(childClassName);
        } catch (final ClassNotFoundException ex) {
            throw new LinkageError("" + childClassName + " is not loaded properly.", ex);
        }
    }

    private static String message(final String className) {
        if (className == null) {
            return "(Invalid class name) is not loaded properly.";
        }
        return className + " is not loaded properly.";
    }

    @SuppressWarnings("unchecked")
    private static <T extends Throwable> void throwException(final Throwable exception, final Object dummy) throws T {
        throw (T) exception;
    }

    private static void throwCheckedException(final Throwable exception) {
        IndirectConstructor.<RuntimeException>throwException(exception, null);
    }
}