docs: @Override
      void open(final WorkQueue<ClasspathEntryWorkUnit> workQueue, final LogNode log) throws InterruptedException {
          if (!scanSpec.scanJars) {
              if (log != null) {
                  log.log("Skipping classpath element, since jar scanning is disabled: " + rawPath);
              }
              skipClasspathElement = true;
              return;
          }
          final LogNode subLog = log == null ? null : log.log("Opening jar: " + rawPath);
          final int plingIdx = rawPath.indexOf('!');
          final String outermostZipFilePathResolved = FastPathResolver.resolve(FileUtils.CURR_DIR_PATH,
                  plingIdx < 0 ? rawPath : rawPath.substring(0, plingIdx));
          if (!scanSpec.jarWhiteBlackList.isWhitelistedAndNotBlacklisted(outermostZipFilePathResolved)) {
              if (subLog != null) {
                  subLog.log("Skipping jarfile that is blacklisted or not whitelisted: " + rawPath);
              }
              skipClasspathElement = true;
              return;
          }
  
          try {
              // Get LogicalZipFile for innermost nested jarfile
              Entry<LogicalZipFile, String> logicalZipFileAndPackageRoot;
              try {
                  logicalZipFileAndPackageRoot = nestedJarHandler.nestedPathToLogicalZipFileAndPackageRootMap
                          .get(rawPath, subLog);
              } catch (final NullSingletonException e) {
                  // Generally thrown on the second and subsequent attempt to call .get(), after the first failed
                  throw new IOException("Could not get logical zipfile " + rawPath + " : " + e);
              }
              logicalZipFile = logicalZipFileAndPackageRoot.getKey();
              if (logicalZipFile == null) {
                  // Should not happen, but this keeps lgtm static analysis happy
                  throw new IOException("Logical zipfile was null");
              }
  
              // Get the normalized path of the logical zipfile
              zipFilePath = FastPathResolver.resolve(FileUtils.CURR_DIR_PATH, logicalZipFile.getPath());
  
              // Get package root of jarfile 
              final String packageRoot = logicalZipFileAndPackageRoot.getValue();
              if (!packageRoot.isEmpty()) {
                  packageRootPrefix = packageRoot + "/";
              }
          } catch (final IOException | IllegalArgumentException e) {
              if (subLog != null) {
                  subLog.log("Could not open jarfile " + rawPath + " : " + e);
              }
              skipClasspathElement = true;
              return;
          }
  
          if (!scanSpec.enableSystemJarsAndModules && logicalZipFile.isJREJar) {
              // Found a blacklisted JRE jar that was not caught by filtering for rt.jar in ClasspathFinder
              // (the isJREJar value was set by detecting JRE headers in the jar's manifest file)
              if (subLog != null) {
                  subLog.log("Ignoring JRE jar: " + rawPath);
              }
              skipClasspathElement = true;
              return;
          }
  
          if (!logicalZipFile.isWhitelistedAndNotBlacklisted(scanSpec.jarWhiteBlackList)) {
              if (subLog != null) {
                  subLog.log("Skipping jarfile that is blacklisted or not whitelisted: " + rawPath);
              }
              skipClasspathElement = true;
              return;
          }
  
          // Automatically add any nested "lib/" dirs to classpath, since not all classloaders return them
          // as classpath elements
          int childClasspathEntryIdx = 0;
          if (scanSpec.scanNestedJars) {
              for (final FastZipEntry zipEntry : logicalZipFile.entries) {
                  for (final String libDirPrefix : ClassLoaderHandlerRegistry.AUTOMATIC_LIB_DIR_PREFIXES) {
                      if (zipEntry.entryNameUnversioned.startsWith(libDirPrefix)
                              && zipEntry.entryNameUnversioned.endsWith(".jar")) {
                          final String entryPath = zipEntry.getPath();
                          if (subLog != null) {
                              subLog.log("Found nested lib jar: " + entryPath);
                          }
                          workQueue.addWorkUnit(new ClasspathEntryWorkUnit(
                                  /* rawClasspathEntry = */ new SimpleEntry<>(entryPath, classLoader),
                                  /* parentClasspathElement = */ this,
                                  /* orderWithinParentClasspathElement = */
                                  childClasspathEntryIdx++));
                          break;
                      }
                  }
              }
          }
  
          // Don't add child classpath elements that are identical to this classpath element, or that are duplicates
          final Set<String> scheduledChildClasspathElements = new HashSet<>();
          scheduledChildClasspathElements.add(rawPath);
  
          // Create child classpath elements from values obtained from Class-Path entry in manifest, resolving
          // the paths relative to the dir or parent jarfile that the jarfile is contained in
          if (logicalZipFile.classPathManifestEntryValue != null) {
              // Get parent dir of logical zipfile within grandparent slice,
              // e.g. for a zipfile slice path of "/path/to/jar1.jar!/lib/jar2.jar", this is "lib",
              // or for "/path/to/jar1.jar", this is "/path/to", or "" if the jar is in the toplevel dir.
              final String jarParentDir = FileUtils
                      .getParentDirPath(logicalZipFile.getPathWithinParentZipFileSlice());
              // Add paths in manifest file's "Class-Path" entry to the classpath, resolving paths relative to
              // the parent directory or jar
              for (final String childClassPathEltPathRelative : logicalZipFile.classPathManifestEntryValue
                      .split(" ")) {
                  if (!childClassPathEltPathRelative.isEmpty()) {
                      // Resolve Class-Path entry relative to containing dir
                      String childClassPathEltPath = FastPathResolver.resolve(jarParentDir,
                              childClassPathEltPathRelative);
                      // If this is a nested jar, prepend outer jar prefix
                      final ZipFileSlice parentZipFileSlice = logicalZipFile.getParentZipFileSlice();
                      if (parentZipFileSlice != null) {
                          childClassPathEltPath = parentZipFileSlice.getPath()
                                  + (childClassPathEltPath.startsWith("/") ? "!" : "!/") + childClassPathEltPath;
                      }
                      // Only add child classpath elements once
                      if (scheduledChildClasspathElements.add(childClassPathEltPath)) {
                          // Schedule child classpath element for scanning
                          workQueue.addWorkUnit( //
                                  new ClasspathEntryWorkUnit(
                                          /* rawClasspathEntry = */ new SimpleEntry<>(childClassPathEltPath,
                                                  classLoader),
                                          /* parentClasspathElement = */ this,
                                          /* orderWithinParentClasspathElement = */
                                          childClasspathEntryIdx++));
                      }
                  }
              }
          }
          // Add paths in an OSGi bundle jar manifest's "Bundle-ClassPath" entry to the classpath, resolving 
          // the paths relative to the root of the jarfile
          if (logicalZipFile.bundleClassPathManifestEntryValue != null) {
              final String zipFilePathPrefix = zipFilePath + "!/";
              // Class-Path is split on " ", but Bundle-ClassPath is split on ","
              for (String childBundlePath : logicalZipFile.bundleClassPathManifestEntryValue.split(",")) {
                  // Assume that Bundle-ClassPath paths have to be given relative to jarfile root
                  while (childBundlePath.startsWith("/")) {
                      childBundlePath = childBundlePath.substring(1);
                  }
                  // Currently the position of "." relative to child classpath entries is ignored (the
                  // Bundle-ClassPath path is treated as if "." is in the first position, since child
                  // classpath entries are always added to the classpath after the parent classpath
                  // entry that they were obtained from).
                  if (!childBundlePath.isEmpty() && !childBundlePath.equals(".")) {
                      // Resolve Bundle-ClassPath entry within jar
                      final String childClassPathEltPath = zipFilePathPrefix
                              + FileUtils.sanitizeEntryPath(childBundlePath, /* removeInitialSlash = */ true);
                      // Only add child classpath elements once
                      if (scheduledChildClasspathElements.add(childClassPathEltPath)) {
                          // Schedule child classpath element for scanning
                          workQueue.addWorkUnit(new ClasspathEntryWorkUnit(
                                  /* rawClasspathEntry = */ //
                                  new SimpleEntry<>(childClassPathEltPath, classLoader),
                                  /* parentClasspathElement = */ this,
                                  /* orderWithinParentClasspathElement = */
                                  childClasspathEntryIdx++));
                      }
                  }
              }
          }
      }