docs: public static Set<String> getIFixesThatMustBeReapplied(File installDir, Map<String, ProvisioningFeatureDefinition> features,
                                                             ContentBasedLocalBundleRepository repo, CommandConsole console) {
  
          Set<String> ifixesToReApply = new HashSet<String>();
  
          Map<File, Map<String, Version>> allBaseBundleJarContent = new HashMap<File, Map<String, Version>>();
          Set<File> allBundleJarContent = new HashSet<File>();
          Set<File> allStaticFileContent = new HashSet<File>();
          // Process all subsystem content of all manifests and store them in the set. We'll use that to process the ifix files.
          processSubsystemContent(installDir, features, repo, allBaseBundleJarContent, allBundleJarContent, allStaticFileContent, console);
  
          // Get a list of all the LibertyProfile metadata files that use to match up with the ifixes.
          Map<String, BundleFile> bundleFiles = processLPMFXmls(installDir, console);
  
          // Iterate over each file that is found in all the ifix xmls. If the same file is listed in multiple ifix xml, we will have
          // been given the new version that should be on the system, if it relevant to the runtime.
          for (Map.Entry<String, IFixInfo> ifixInfoEntry : processIFixXmls(installDir, bundleFiles, console).entrySet()) {
  
              // Get the relative file name of the ifix file e.g. lib/test_1.0.0.20130101.jar
              String updateFileName = ifixInfoEntry.getKey();
              // Get the IfixInfo object that contains the latest version of this file.
              IFixInfo ifixInfo = ifixInfoEntry.getValue();
  
              // Loop through all the updated files in the current ifixInfo and when we've found the required file to
              // process, do the rest of the processing.
              for (UpdatedFile updatedFile : ifixInfo.getUpdates().getFiles()) {
                  if (updatedFile.getId().equals(updateFileName)) {
  
                      File updateFile = new File(installDir, updateFileName);
                      // Check to see if we're dealing with a static content file or not. If not see if it is a bundle. If not then ignore as we
                      // don't need it.
                      if (allStaticFileContent.contains(updateFile)) {
                          // Check that the file exists in the runtime.
                          if (updateFile.exists()) {
                              // Get the hash of the static file from the ifix xml file.
                              String ifixHash = updatedFile.getHash();
                              // Now calculate the new hash and compare the 2. If they are NOT the same the ifix needs to be re-applied.
                              try {
                                  // Now calculate the new hash and compare each hash. If they are NOT the same the ifix needs to be re-applied.
                                  if (!equalsHashes(updateFile, ifixHash))
                                      ifixesToReApply.add(ifixInfo.getId());
  
                              } catch (IOException ioe) {
                                  console.printlnErrorMessage(getMessage("ifixutils.unable.to.read.file", updateFile.getAbsolutePath(), ioe.getMessage()));
                              }
  
                          } else {
                              // If the static file doesn't appear on disk, then we need to re-apply the ifix.
                              ifixesToReApply.add(ifixInfo.getId());
                          }
                          // Process jar files. If the ifix jar doesn't exist, then check to see whether we have the relevant
                          // features installed that would require the ifix to be re-applied.
                      } else {
                          // If we're not dealing with static files, then we should be dealing with bundles and or static jars.
                          // If we have the actual ifix jar in the runtime, we need to check that it is the correct file. Check that hash.
                          if (allBundleJarContent.contains(updateFile)) {
                              // Get the hash of the bundle from the ifix xml file.
                              String ifixHash = updatedFile.getHash();
                              try {
                                  // Now calculate the new hash and compare both hashes. If they are NOT the same the ifix needs to be re-applied.
                                  if (!equalsHashes(updateFile, ifixHash))
                                      ifixesToReApply.add(ifixInfo.getId());
                              } catch (IOException ioe) {
                                  console.printlnErrorMessage(getMessage("ifixutils.unable.to.read.file", updateFile.getAbsolutePath(), ioe.getMessage()));
                              }
                          } else {
                              // If the ifix jar isn't in the runtime, we need to check that the base bundle it is an ifix for does. If this doesn't
                              // exist we can then ignore the ifix.
                              // Find the BundleFile associated with the ifix file.
                              BundleFile bundleFile = bundleFiles.get(updatedFile.getId());
                              // If we don't have one, then we're not a jar file we know about. We know ignore this file.
                              if (bundleFile != null) {
                                  // Get the symbolic name and version of the ifix jar we're dealing with.
                                  String bundleSymbolicName = bundleFile.getSymbolicName();
                                  Version bundleVersion = new Version(bundleFile.getVersion());
  
                                  // Now iterate over all the bundles we know about in the runtime, and see if we can find a matching base bundle.
                                  // If we can we need to reapply the ifix, otherwise we can ignore.
                                  boolean found = false;
                                  for (Iterator<Map<String, Version>> iter = allBaseBundleJarContent.values().iterator(); iter.hasNext() && !found;) {
                                      for (Map.Entry<String, Version> bundleEntry : iter.next().entrySet()) {
                                          // If we have a matching symbolic name and the version matches (ignoring the qualifier) then we have a base bundle on the
                                          // system.
                                          String entrySymbolicName = bundleEntry.getKey();
                                          Version entryVersion = bundleEntry.getValue();
                                          if (bundleSymbolicName.equals(entrySymbolicName) &&
                                              bundleVersion.getMajor() == entryVersion.getMajor() &&
                                              bundleVersion.getMinor() == entryVersion.getMinor() &&
                                              bundleVersion.getMicro() == entryVersion.getMicro()) {
                                              found = true;
                                          }
                                      }
                                  }
                                  // If we have found a base bundle, report we need to reinstall the ifix.
                                  if (found)
                                      ifixesToReApply.add(ifixInfo.getId());
                              }
                          }
                      }
                  }
              }
          }
          return ifixesToReApply;
      }