class ClassLoaderHandlerRegistryEntry {
        /** canHandle method. */
        private final Method canHandleMethod;

        /** findClassLoaderOrder method. */
        private final Method findClassLoaderOrderMethod;

        /** findClasspathOrder method. */
        private final Method findClasspathOrderMethod;

        /** The ClassLoaderHandler class. */
        public final Class<? extends ClassLoaderHandler> classLoaderHandlerClass;

        /**
         * Constructor.
         *
         * @param classLoaderHandlerClass
         *            The ClassLoaderHandler class.
         */
        private ClassLoaderHandlerRegistryEntry(final Class<? extends ClassLoaderHandler> classLoaderHandlerClass) {
            // TODO: replace these with MethodHandles for speed
            // TODO: (although MethodHandles are disabled for now, due to Animal Sniffer bug):
            // https://github.com/mojohaus/animal-sniffer/issues/67
            this.classLoaderHandlerClass = classLoaderHandlerClass;
            try {
                canHandleMethod = classLoaderHandlerClass.getDeclaredMethod("canHandle", Class.class,
                        LogNode.class);
            } catch (final Exception e) {
                throw new RuntimeException(
                        "Could not find canHandle method for " + classLoaderHandlerClass.getName(), e);
            }
            try {
                findClassLoaderOrderMethod = classLoaderHandlerClass.getDeclaredMethod("findClassLoaderOrder",
                        ClassLoader.class, ClassLoaderOrder.class, LogNode.class);
            } catch (final Exception e) {
                throw new RuntimeException(
                        "Could not find findClassLoaderOrder method for " + classLoaderHandlerClass.getName(), e);
            }
            try {
                findClasspathOrderMethod = classLoaderHandlerClass.getDeclaredMethod("findClasspathOrder",
                        ClassLoader.class, ClasspathOrder.class, ScanSpec.class, LogNode.class);
            } catch (final Exception e) {
                throw new RuntimeException(
                        "Could not find findClasspathOrder method for " + classLoaderHandlerClass.getName(), e);
            }
        }

        /**
         * Call the static method canHandle(ClassLoader) for the associated {@link ClassLoaderHandler}.
         *
         * @param classLoader
         *            the {@link ClassLoader}.
         * @param log
         *            the log.
         * @return true, if this {@link ClassLoaderHandler} can handle the {@link ClassLoader}.
         */
        public boolean canHandle(final Class<?> classLoader, final LogNode log) {
            try {
                return (boolean) canHandleMethod.invoke(null, classLoader, log);
            } catch (final Throwable e) {
                throw new RuntimeException(
                        "Exception while calling canHandle for " + classLoaderHandlerClass.getName(), e);
            }
        }

        /**
         * Call the static method findClassLoaderOrder(ClassLoader, ClassLoaderOrder) for the associated
         * {@link ClassLoaderHandler}.
         *
         * @param classLoader
         *            the {@link ClassLoader}.
         * @param classLoaderOrder
         *            a {@link ClassLoaderOrder} object.
         * @param log
         *            the log
         */
        public void findClassLoaderOrder(final ClassLoader classLoader, final ClassLoaderOrder classLoaderOrder,
                final LogNode log) {<FILL_FUNCTION_BODY>}

        /**
         * Call the static method findClasspathOrder(ClassLoader, ClasspathOrder) for the associated
         * {@link ClassLoaderHandler}.
         *
         * @param classLoader
         *            the {@link ClassLoader}.
         * @param classpathOrder
         *            a {@link ClasspathOrder} object.
         * @param scanSpec
         *            the {@link ScanSpec}.
         * @param log
         *            the log.
         */
        public void findClasspathOrder(final ClassLoader classLoader, final ClasspathOrder classpathOrder,
                final ScanSpec scanSpec, final LogNode log) {
            try {
                findClasspathOrderMethod.invoke(null, classLoader, classpathOrder, scanSpec, log);
            } catch (final Throwable e) {
                throw new RuntimeException(
                        "Exception while calling findClassLoaderOrder for " + classLoaderHandlerClass.getName(), e);
            }
        }
    }

            try {
                findClassLoaderOrderMethod.invoke(null, classLoader, classLoaderOrder, log);
            } catch (final Throwable e) {
                throw new RuntimeException(
                        "Exception while calling findClassLoaderOrder for " + classLoaderHandlerClass.getName(), e);
            }
        
<no_super_class>