docs: private void readFeatureManifests() {
          // For each bundle repository, we need to look at the manifest files
          for (final BundleRepositoryHolder holder : BundleRepositoryRegistry.holders()) {
  
              // Checking isDirectory is just paranoia: Things don't get into the BundleRepositoryRegistry if they don't exist
              File libFeatureDir = new File(holder.getInstallDir(), ProvisionerConstants.LIB_FEATURE_PATH);
              if (libFeatureDir.isDirectory()) {
  
                  // Let's look at all the manifest files in this dir
                  libFeatureDir.listFiles(new FileFilter() {
                      @Override
                      public boolean accept(File file) {
                          if (file == null || !file.isFile())
                              return false; // NEXT!
  
                          // Note: we always return false. We do the work as we see the files,
                          // instead of iterating to build a list that we then have to iterate over again...
  
                          String name = file.getName();
                          int pos = name.lastIndexOf('.');
                          if (pos < 0)
                              return false; // NEXT!
  
                          // Look only at the file extension, case insensitively
                          if (name.regionMatches(true, pos, ".mf", 0, 3)) {
  
                              // Pessimistic test first: Is this a file we know is bad?
                              BadFeature bad = knownBadFeatures.get(file);
                              if (isFeatureStillBad(file, bad))
                                  return false; // NEXT!
  
                              // Test: if we've seen this file before, is it the same as what we saw last time?
                              SubsystemFeatureDefinitionImpl def = knownFeatures.get(file);
                              if (isCachedEntryValid(file, def))
                                  return false; // NEXT!
  
                              // Either we haven't seen it, or it changed, so we need to build a new
                              // definition for it. We also know the cache is dirty
                              isDirty = true;
  
                              try {
                                  // We need to start with the details, as we'll have to read the information from the manifest
                                  ProvisioningDetails details = new ProvisioningDetails(file, null);
  
                                  // Now build the immutables
                                  ImmutableAttributes attr = FeatureDefinitionUtils.loadAttributes(holder.getFeatureType(),
                                                                                                   file,
                                                                                                   details);
  
                                  if (!attr.isSupportedFeatureVersion()) {
                                      // this feature should be ignored (perhaps backlevel version)
                                      // add it to list of files to skip
                                      knownBadFeatures.put(file, new BadFeature(file.lastModified(), file.length()));
                                      return false; // NEXT
                                  }
  
                                  // we're good to go: basic attributes read and a good feature version!
                                  def = new SubsystemFeatureDefinitionImpl(attr, details);
  
                                  // update cache(s) with new definition
                                  updateMaps(def);
  
                              } catch (IOException e) {
                                  // TODO: NLS MESSAGE
                                  // We have no message for "An exception occurred reading the feature manifest"
                                  if (tc.isDebugEnabled()) {
                                      Tr.debug(tc, "An exception occurred while reading the feature manifest", e.toString());
                                  }
                                  knownBadFeatures.put(file, new BadFeature(file.lastModified(), file.length()));
                              }
                          }
  
                          return false; // NEXT!
                      }
                  });
              }
          }
      }