docs: private static void localize( final Class<?> i18nClass,
                                    final Locale locale ) {
          assert i18nClass != null;
          assert locale != null;
          // Create a class-to-problem map for this locale if one doesn't exist, else get the existing one.
          Map<Class<?>, Set<String>> classToProblemsMap = new ConcurrentHashMap<Class<?>, Set<String>>();
          Map<Class<?>, Set<String>> existingClassToProblemsMap = LOCALE_TO_CLASS_TO_PROBLEMS_MAP.putIfAbsent(locale,
                                                                                                              classToProblemsMap);
          if (existingClassToProblemsMap != null) {
              classToProblemsMap = existingClassToProblemsMap;
          }
          // Check if already localized outside of synchronization block for 99% use-case
          if (classToProblemsMap.get(i18nClass) != null) {
              return;
          }
          synchronized (i18nClass) {
              // Return if the supplied i18n class has already been localized to the supplied locale, despite the check outside of
              // the synchronization block (1% use-case), else create a class-to-problems map for the class.
              Set<String> problems = classToProblemsMap.get(i18nClass);
              if (problems == null) {
                  problems = new CopyOnWriteArraySet<String>();
                  classToProblemsMap.put(i18nClass, problems);
              } else {
                  return;
              }
              // Get the URL to the localization properties file ...
              final String localizationBaseName = i18nClass.getName();
              URL bundleUrl = ClasspathLocalizationRepository.getLocalizationBundle(i18nClass.getClassLoader(), localizationBaseName, locale);
              if (bundleUrl == null && i18nClass == CommonI18n.class) {
                  throw new SystemFailureException("CommonI18n.properties file not found in classpath !");
              }
              if (bundleUrl == null) {
                  LOGGER.warn(CommonI18n.i18nBundleNotFoundInClasspath,
                              ClasspathLocalizationRepository.getPathsToSearchForBundle(localizationBaseName, locale));
                  // Nothing was found, so try the default locale
                  Locale defaultLocale = Locale.getDefault();
                  if (!defaultLocale.equals(locale)) {
                      bundleUrl = ClasspathLocalizationRepository.getLocalizationBundle(i18nClass.getClassLoader(), localizationBaseName, defaultLocale);
                  }
                  // Return if no applicable localization file could be found
                  if (bundleUrl == null) {
                      LOGGER.error(CommonI18n.i18nBundleNotFoundInClasspath,
                                   ClasspathLocalizationRepository.getPathsToSearchForBundle(localizationBaseName, defaultLocale));
                      LOGGER.error(CommonI18n.i18nLocalizationFileNotFound, localizationBaseName);
                      problems.add(CommonI18n.i18nLocalizationFileNotFound.text(localizationBaseName));
                      return;
                  }
              }
              // Initialize i18n map
              Properties props = prepareBundleLoading(i18nClass, locale, bundleUrl, problems);
  
              try {
                  InputStream propStream = bundleUrl.openStream();
                  try {
                      props.load(propStream);
                      // Check for uninitialized fields
                      for (Field fld : i18nClass.getDeclaredFields()) {
                          if (fld.getType() == I18n.class) {
                              try {
                                  I18n i18n = (I18n)fld.get(null);
                                  if (i18n.localeToTextMap.get(locale) == null) {
                                      i18n.localeToProblemMap.put(locale,
                                                                  CommonI18n.i18nPropertyMissing.text(fld.getName(), bundleUrl));
                                  }
                              } catch (IllegalAccessException notPossible) {
                                  // Would have already occurred in initialize method, but allowing for the impossible...
                                  problems.add(notPossible.getMessage());
                              }
                          }
                      }
                  } finally {
                      propStream.close();
                  }
              } catch (IOException err) {
                  problems.add(err.getMessage());
              }
          }
      }