class SkipClassException extends IOException {
        /** serialVersionUID. */
        static final long serialVersionUID = 1L;

        /**
         * Constructor.
         *
         * @param message
         *            the message
         */
        public SkipClassException(final String message) {
            super(message);
        }

        /**
         * Speed up exception (stack trace is not needed for this exception).
         *
         * @return this
         */
        @Override
        public synchronized Throwable fillInStackTrace() {
            return this;
        }
    }

    // -------------------------------------------------------------------------------------------------------------

    /**
     * Extend scanning to a superclass, interface or annotation.
     *
     * @param className
     *            the class name
     * @param relationship
     *            the relationship type
     * @param log
     *            the log
     */
    private void scheduleScanningIfExternalClass(final String className, final String relationship,
            final LogNode log) {<FILL_FUNCTION_BODY>

        // Don't scan Object
        if (className != null && !className.equals("java.lang.Object")
        // Don't schedule a class for scanning that was already found to be accepted
                && !acceptedClassNamesFound.contains(className)
                // Only schedule each external class once for scanning, across all threads
                && classNamesScheduledForExtendedScanning.add(className)) {
            if (scanSpec.classAcceptReject.isRejected(className)) {
                if (log != null) {
                    log.log("Cannot extend scanning upwards to external " + relationship + " " + className
                            + ", since it is rejected");
                }
            } else {
                // Search for the named class' classfile among classpath elements, in classpath order (this is O(N)
                // for each class, but there shouldn't be too many cases of extending scanning upwards)
                final String classfilePath = JarUtils.classNameToClassfilePath(className);
                // First check current classpath element, to avoid iterating through other classpath elements
                Resource classResource = classpathElement.getResource(classfilePath);
                ClasspathElement foundInClasspathElt = null;
                if (classResource != null) {
                    // Found the classfile in the current classpath element
                    foundInClasspathElt = classpathElement;
                } else {
                    // Didn't find the classfile in the current classpath element -- iterate through other elements
                    for (final ClasspathElement classpathOrderElt : classpathOrder) {
                        if (classpathOrderElt != classpathElement) {
                            classResource = classpathOrderElt.getResource(classfilePath);
                            if (classResource != null) {
                                foundInClasspathElt = classpathOrderElt;
                                break;
                            }
                        }
                    }
                }
                if (classResource != null) {
                    // Found class resource 
                    if (log != null) {
                        // Log the extended scan as a child LogNode of the current class' scan log, since the
                        // external class is not scanned at the regular place in the classpath element hierarchy
                        // traversal
                        classResource.scanLog = log
                                .log("Extending scanning to external " + relationship
                                        + (foundInClasspathElt == classpathElement ? " in same classpath element"
                                                : " in classpath element " + foundInClasspathElt)
                                        + ": " + className);
                    }
                    if (additionalWorkUnits == null) {
                        additionalWorkUnits = new ArrayList<>();
                    }
                    // Schedule class resource for scanning
                    additionalWorkUnits.add(new ClassfileScanWorkUnit(foundInClasspathElt, classResource,
                            /* isExternalClass = */ true));
                } else {
                    if (log != null) {
                        log.log("External " + relationship + " " + className + " was not found in "
                                + "non-rejected packages -- cannot extend scanning to this class");
                    }
                }
            }
        }
    
<no_super_class>