docs: private ScanResult openClasspathElementsThenScan() throws InterruptedException, ExecutionException {
          // Get order of elements in traditional classpath
          final List<ClasspathEntryWorkUnit> rawClasspathEntryWorkUnits = new ArrayList<>();
          for (final Entry<String, ClassLoader> rawClasspathEntry : classpathFinder.getClasspathOrder().getOrder()) {
              rawClasspathEntryWorkUnits
                      .add(new ClasspathEntryWorkUnit(rawClasspathEntry, /* parentClasspathElement = */ null,
                              /* orderWithinParentClasspathElement = */ rawClasspathEntryWorkUnits.size()));
          }
  
          // In parallel, create a ClasspathElement singleton for each classpath element, then call open()
          // on each ClasspathElement object, which in the case of jarfiles will cause LogicalZipFile instances
          // to be created for each (possibly nested) jarfile, then will read the manifest file and zip entries.
          final Set<ClasspathElement> openedClasspathEltsSet = Collections
                  .newSetFromMap(new ConcurrentHashMap<ClasspathElement, Boolean>());
          final Queue<Entry<Integer, ClasspathElement>> toplevelClasspathEltOrder = new ConcurrentLinkedQueue<>();
          processWorkUnits(rawClasspathEntryWorkUnits,
                  topLevelLog == null ? null : topLevelLog.log("Opening classpath elements"),
                  newClasspathEntryWorkUnitProcessor(openedClasspathEltsSet, toplevelClasspathEltOrder));
  
          // Determine total ordering of classpath elements, inserting jars referenced in manifest Class-Path
          // entries in-place into the ordering, if they haven't been listed earlier in the classpath already.
          final List<ClasspathElement> classpathEltOrder = findClasspathOrder(openedClasspathEltsSet,
                  toplevelClasspathEltOrder);
  
          // Find classpath elements that are path prefixes of other classpath elements, and for
          // ClasspathElementZip, get module-related manifest entry values
          preprocessClasspathElementsByType(classpathEltOrder,
                  topLevelLog == null ? null : topLevelLog.log("Finding nested classpath elements"));
  
          // Order modules before classpath elements from traditional classpath 
          final LogNode classpathOrderLog = topLevelLog == null ? null
                  : topLevelLog.log("Final classpath element order:");
          final int numElts = moduleClasspathEltOrder.size() + classpathEltOrder.size();
          final List<ClasspathElement> finalClasspathEltOrder = new ArrayList<>(numElts);
          final List<String> finalClasspathEltOrderStrs = new ArrayList<>(numElts);
          for (final ClasspathElementModule classpathElt : moduleClasspathEltOrder) {
              finalClasspathEltOrder.add(classpathElt);
              finalClasspathEltOrderStrs.add(classpathElt.toString());
              if (classpathOrderLog != null) {
                  final ModuleRef moduleRef = classpathElt.getModuleRef();
                  classpathOrderLog.log(moduleRef.toString());
              }
          }
          for (final ClasspathElement classpathElt : classpathEltOrder) {
              finalClasspathEltOrder.add(classpathElt);
              finalClasspathEltOrderStrs.add(classpathElt.toString());
              if (classpathOrderLog != null) {
                  classpathOrderLog.log(classpathElt.toString());
              }
          }
  
          // In parallel, scan paths within each classpath element, comparing them against whitelist/blacklist
          processWorkUnits(finalClasspathEltOrder,
                  topLevelLog == null ? null : topLevelLog.log("Scanning classpath elements"),
                  new WorkUnitProcessor<ClasspathElement>() {
                      @Override
                      public void processWorkUnit(final ClasspathElement classpathElement,
                              final WorkQueue<ClasspathElement> workQueueIgnored, final LogNode pathScanLog)
                              throws InterruptedException {
                          // Scan the paths within the classpath element
                          classpathElement.scanPaths(pathScanLog);
                      }
                  });
  
          // Filter out classpath elements that do not contain required whitelisted paths.
          List<ClasspathElement> finalClasspathEltOrderFiltered = finalClasspathEltOrder;
          if (!scanSpec.classpathElementResourcePathWhiteBlackList.whitelistIsEmpty()) {
              finalClasspathEltOrderFiltered = new ArrayList<>(finalClasspathEltOrder.size());
              for (final ClasspathElement classpathElement : finalClasspathEltOrder) {
                  if (classpathElement.containsSpecificallyWhitelistedClasspathElementResourcePath) {
                      finalClasspathEltOrderFiltered.add(classpathElement);
                  }
              }
          }
  
          if (scanSpec.performScan) {
              // Scan classpath / modules, producing a ScanResult.
              return performScan(finalClasspathEltOrderFiltered, finalClasspathEltOrderStrs,
                      classLoaderOrderRespectingParentDelegation);
          } else {
              // Only getting classpath -- return a placeholder ScanResult to hold classpath elements
              if (topLevelLog != null) {
                  topLevelLog.log("Only returning classpath elements (not performing a scan)");
              }
              return new ScanResult(scanSpec, finalClasspathEltOrderFiltered, finalClasspathEltOrderStrs,
                      classLoaderOrderRespectingParentDelegation, /* classNameToClassInfo = */ null,
                      /* packageNameToPackageInfo = */ null, /* moduleNameToModuleInfo = */ null,
                      /* fileToLastModified = */ null, nestedJarHandler, topLevelLog);
          }
      }