public List<String> getExternalsWithResolutionOrder(Permutation permutation) {
   if (permutation == null) {
     return null;
   }
   List<String> result = new ArrayList<String>(4);
   result.add(permutation.toExternal());
   Locale locale = permutation.getLocale();
   if (locale != null) {
     String localeStr = locale.toString();
     if (!result.contains(localeStr)) {
       result.add(localeStr);
     }
     if (locale.getVariant() != null && locale.getVariant().length() != 0) {
       Locale localeWithVar = new Locale(locale.getLanguage(), locale.getCountry());
       localeStr = localeWithVar.toString();
       if (!result.contains(localeStr)) {
         result.add(localeStr);
       }
     }
     if (locale.getCountry() != null && locale.getCountry().length() != 0) {
       Locale localeWithCountry = new Locale(locale.getLanguage());
       localeStr = localeWithCountry.toString();
       if (!result.contains(localeStr)) {
         result.add(localeStr);
       }
     }
   }
   result.add("");
   return result;
 }
Exemple #2
0
  /**
   * Returns any occurrence of the specified Locale or any its fallback in the value collection, or
   * null if not found. By fallback, we mean will try without variant and country. Example, if
   * locale is zh_TW, it will try zh_TW and then zh.
   */
  public static Locale getByFallback(Collection<Locale> values, Locale locale) {
    if (values.contains(locale)) return locale;

    final String lang = locale.getLanguage();
    final String cnty = locale.getCountry();
    final String var = locale.getVariant();
    if (var != null && var.length() > 0) {
      locale = new Locale(lang, cnty);
      if (values.contains(locale)) return locale;
    }
    if (cnty != null && cnty.length() > 0) {
      locale = new Locale(lang, "");
      if (values.contains(locale)) return locale;
    }

    // search the first one that matches partially
    Locale rtn = null;
    for (Locale l : values) {
      if (l.getLanguage().equals(lang)) {
        // case 1: it matches all but the last element -> done
        if (var == null
            || var.length() == 0
            || Objects.equals(l.getCountry(), cnty)) // country might null
        return l;

        // case 2: it matches only language, we seeek for any case 1
        if (rtn == null) rtn = l;
      }
    }
    return rtn;
  }
  private static Locale _getSuperLocale(Locale locale) {
    String variant = locale.getVariant();

    if (variant.length() > 0) {
      return new Locale(locale.getLanguage(), locale.getCountry());
    }

    String country = locale.getCountry();

    if (country.length() > 0) {
      Locale priorityLocale = LanguageUtil.getLocale(locale.getLanguage());

      if ((priorityLocale != null) && !locale.equals(priorityLocale)) {
        return new Locale(priorityLocale.getLanguage(), priorityLocale.getCountry());
      }

      return LocaleUtil.fromLanguageId(locale.getLanguage(), false, true);
    }

    String language = locale.getLanguage();

    if (language.length() > 0) {
      return _blankLocale;
    }

    return null;
  }
  /*
   * (non-Javadoc)
   * @see at.alladin.rmbt.db.dao.PrimaryKeyDao#getAll()
   */
  @Override
  public List<QoSTestTypeDesc> getAll() throws SQLException {
    List<QoSTestTypeDesc> resultList = new ArrayList<>();
    try (PreparedStatement psGetAll =
        conn.prepareStatement(
            "SELECT nnttd.uid AS uid, test, nntd.\"value\", nntd.lang, nntd2.\"value\" AS value_name, nntd2.lang AS name_lang "
                + " FROM qos_test_type_desc AS nnttd "
                + " JOIN qos_test_desc nntd ON nnttd.test_desc = nntd.desc_key "
                + " JOIN qos_test_desc nntd2 ON nnttd.test_name = nntd2.desc_key"
                + " WHERE nntd.lang = ("
                + "	CASE WHEN EXISTS(SELECT 1 FROM qos_test_desc WHERE desc_key = nntd.desc_key AND lang = ?) "
                + " 	THEN ? ELSE 'en' END)"
                + " AND nntd2.lang = ("
                + "	CASE WHEN EXISTS(SELECT 1 FROM qos_test_desc WHERE desc_key = nntd2.desc_key AND lang = ?) "
                + " 	THEN ? ELSE 'en' END)")) {

      psGetAll.setString(1, locale.getLanguage());
      psGetAll.setString(2, locale.getLanguage());
      psGetAll.setString(3, locale.getLanguage());
      psGetAll.setString(4, locale.getLanguage());

      if (psGetAll.execute()) {
        try (ResultSet rs = psGetAll.getResultSet()) {
          while (rs.next()) {
            resultList.add(instantiateItem(rs));
          }
        }
        return resultList;
      } else {
        throw new SQLException("no result set");
      }
    }
  }
Exemple #5
0
  public static Locale localeMatch(List<String> requestedLocales, List<Locale> availableLocales) {
    if (requestedLocales == null || availableLocales == null) {
      return null;
    }

    for (String requestedLocale : requestedLocales) {
      Locale reqInQuestion = LocaleUtils.toLocale(requestedLocale);
      List<Locale> lookupList = LocaleUtils.localeLookupList(reqInQuestion);

      for (Locale localeInQuestion : lookupList) {
        for (Locale availableLocale : availableLocales) {
          if (localeInQuestion.equals(availableLocale)) {
            return availableLocale;
          }
        }
      }

      for (Locale availableLocale : availableLocales) {
        if (reqInQuestion.getLanguage().equals(availableLocale.getLanguage())) {
          return availableLocale;
        }
      }
    }

    return null;
  }
Exemple #6
0
  private static void assertObsolete(String newCode, String oldCode, String displayName) {
    // Either code should get you the same locale.
    Locale newLocale = new Locale(newCode);
    Locale oldLocale = new Locale(oldCode);
    assertEquals(newLocale, oldLocale);

    // No matter what code you used to create the locale, you should get the old code back.
    assertEquals(oldCode, newLocale.getLanguage());
    assertEquals(oldCode, oldLocale.getLanguage());

    // Check we get the right display name.
    assertEquals(displayName, newLocale.getDisplayLanguage(newLocale));
    assertEquals(displayName, oldLocale.getDisplayLanguage(newLocale));
    assertEquals(displayName, newLocale.getDisplayLanguage(oldLocale));
    assertEquals(displayName, oldLocale.getDisplayLanguage(oldLocale));

    // Check that none of the 'getAvailableLocales' methods are accidentally returning two
    // equal locales (because to ICU they're different, but we mangle one into the other).
    assertOnce(newLocale, BreakIterator.getAvailableLocales());
    assertOnce(newLocale, Calendar.getAvailableLocales());
    assertOnce(newLocale, Collator.getAvailableLocales());
    assertOnce(newLocale, DateFormat.getAvailableLocales());
    assertOnce(newLocale, DateFormatSymbols.getAvailableLocales());
    assertOnce(newLocale, NumberFormat.getAvailableLocales());
    assertOnce(newLocale, Locale.getAvailableLocales());
  }
  /** This method must be called in a context synchronized on {@link #translationsStatistics}. */
  private static LanguageEntry getSortedLanguageByLocale(Locale locale) {
    for (LanguageEntry entry : sortedLanguages) {
      if (entry.locale.equals(locale)) {
        return entry;
      }
    }

    // No exact match found, try to match only by language and country
    for (LanguageEntry entry : sortedLanguages) {
      if (entry.locale.getCountry().equals(locale.getCountry())
          && entry.locale.getLanguage().equals(locale.getLanguage())) {
        return entry;
      }
    }

    // No match found on language and country, try to match only by language
    for (LanguageEntry entry : sortedLanguages) {
      if (entry.locale.getLanguage().equals(locale.getLanguage())) {
        return entry;
      }
    }

    // No match found on language, try a last desperate match only by country
    if (!locale.getCountry().isEmpty()) {
      for (LanguageEntry entry : sortedLanguages) {
        if (entry.locale.getCountry().equals(locale.getCountry())) {
          return entry;
        }
      }
    }

    // No match found, return null
    return null;
  }
  public List<Locale> getAvailableLanguages() {
    Locale[] locales = Locale.getAvailableLocales();
    Map<String, Locale> localeMap = new HashMap<String, Locale>();

    // remove all variants
    for (Locale locale : locales) {
      if (isTranslationsOnly()
          && !ArrayUtils.contains(config.getAvailableTranslations(), locale.getLanguage())) {
        continue;
      }

      if (localeMap.containsKey(locale.getLanguage())
          && locale.getDisplayName().indexOf('(') != -1) {
        continue;
      }

      localeMap.put(locale.getLanguage(), locale);
    }

    SortedSet<Locale> localeSet =
        new TreeSet<Locale>(new LocaleComparator(LocaleComparator.CompareType.LANGUAGE));

    for (Locale locale : localeMap.values()) {
      localeSet.add(locale);
    }

    return new ArrayList<Locale>(localeSet);
  }
  /**
   * @return
   * @throws SQLException
   */
  public HashMap<TestType, QoSTestTypeDesc> getAllToMap() throws SQLException {
    HashMap<TestType, QoSTestTypeDesc> resultMap = new HashMap<>();
    try (PreparedStatement psGetAll =
        conn.prepareStatement(
            "SELECT nnttd.uid AS uid, test, nntd.\"value\", nntd.lang, nntd2.\"value\" AS value_name, nntd2.lang AS name_lang "
                + " FROM qos_test_type_desc AS nnttd "
                + " JOIN qos_test_desc nntd ON nnttd.test_desc = nntd.desc_key "
                + " JOIN qos_test_desc nntd2 ON nnttd.test_name = nntd2.desc_key"
                + " WHERE nntd.lang = ("
                + "	CASE WHEN EXISTS(SELECT 1 FROM qos_test_desc WHERE desc_key = nntd.desc_key AND lang = ?) "
                + " 	THEN ? ELSE 'en' END)"
                + " AND nntd2.lang = ("
                + "	CASE WHEN EXISTS(SELECT 1 FROM qos_test_desc WHERE desc_key = nntd2.desc_key AND lang = ?) "
                + " 	THEN ? ELSE 'en' END)")) {
      psGetAll.setString(1, locale.getLanguage());
      psGetAll.setString(2, locale.getLanguage());
      psGetAll.setString(3, locale.getLanguage());
      psGetAll.setString(4, locale.getLanguage());

      if (psGetAll.execute()) {
        try (ResultSet rs = psGetAll.getResultSet()) {
          while (rs.next()) {
            QoSTestTypeDesc item = instantiateItem(rs);
            resultMap.put(item.getTestType(), item);
          }
          return resultMap;
        }
      } else {
        throw new SQLException("no result set");
      }
    }
  }
Exemple #10
0
 /**
  * a utility method to answer the name of a resource bundle according to the given base name and
  * locale
  *
  * @param baseName the given base name
  * @param locale the locale to use
  * @return the name of a resource bundle according to the given base name and locale
  */
 public String toBundleName(String baseName, Locale locale) {
   final String emptyString = EMPTY_STRING;
   final String preString = UNDER_SCORE;
   final String underline = UNDER_SCORE;
   if (null == baseName) {
     throw new NullPointerException();
   }
   StringBuilder ret = new StringBuilder();
   StringBuilder prefix = new StringBuilder();
   ret.append(baseName);
   if (!locale.getLanguage().equals(emptyString)) {
     ret.append(underline);
     ret.append(locale.getLanguage());
   } else {
     prefix.append(preString);
   }
   if (!locale.getCountry().equals(emptyString)) {
     ret.append((CharSequence) prefix);
     ret.append(underline);
     ret.append(locale.getCountry());
     prefix = new StringBuilder();
   } else {
     prefix.append(preString);
   }
   if (!locale.getVariant().equals(emptyString)) {
     ret.append((CharSequence) prefix);
     ret.append(underline);
     ret.append(locale.getVariant());
   }
   return ret.toString();
 }
Exemple #11
0
  protected void drawMonthDayLabels(Canvas canvas) {
    int y = getMonthHeaderSize() - (MONTH_DAY_LABEL_TEXT_SIZE / 2);
    int dayWidthHalf = (mWidth - mEdgePadding * 2) / (mNumDays * 2);

    for (int i = 0; i < mNumDays; i++) {
      int x = (2 * i + 1) * dayWidthHalf + mEdgePadding;

      int calendarDay = (i + mWeekStart) % mNumDays;
      mDayLabelCalendar.set(Calendar.DAY_OF_WEEK, calendarDay);
      Locale locale = Locale.getDefault();
      String localWeekDisplayName =
          mDayLabelCalendar.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.SHORT, locale);
      String weekString = localWeekDisplayName.toUpperCase(locale).substring(0, 1);

      if (locale.equals(Locale.CHINA)
          || locale.equals(Locale.CHINESE)
          || locale.equals(Locale.SIMPLIFIED_CHINESE)
          || locale.equals(Locale.TRADITIONAL_CHINESE)) {
        int len = localWeekDisplayName.length();
        weekString = localWeekDisplayName.substring(len - 1, len);
      }

      if (locale.getLanguage().equals("he") || locale.getLanguage().equals("iw")) {
        if (mDayLabelCalendar.get(Calendar.DAY_OF_WEEK) != Calendar.SATURDAY) {
          int len = localWeekDisplayName.length();
          weekString = localWeekDisplayName.substring(len - 2, len - 1);
        } else {
          // I know this is duplication, but it makes the code easier to grok by
          // having all hebrew code in the same block
          weekString = localWeekDisplayName.toUpperCase(locale).substring(0, 1);
        }
      }
      canvas.drawText(weekString, x, y, mMonthDayLabelPaint);
    }
  }
  public String format(String key, String dflt, Object... args) {
    if (key == null) {
      return dflt;
    }
    if (dflt == null) {
      dflt = key;
    }

    Locale locale = CurrentLocale.get();

    // first look for most-specific catalog
    String message = getCatalogMessage(locale, key);
    if (message == null) {
      message = getCatalogMessage(new Locale(locale.getLanguage(), locale.getCountry()), key);
    }
    // now look for language
    if (message == null) {
      message = getCatalogMessage(new Locale(locale.getLanguage()), key);
    }
    // otherwise use the default catalog
    if (message == null) {
      message = getCatalogMessage(new Locale(""), key);
    }
    // and default to framework
    if (message == null) {
      message = getFrameworkMessage(locale, key);
    }
    if (message == null) {
      return dflt;
    } else {
      MessageFormat formater = new MessageFormat(message, locale);
      return formater.format(args, new StringBuffer(), null).toString();
    }
  }
  // Compares the specified locale against the supported variants
  private int _compareLocale(Locale locale) {
    // If we don't have any locales specified, anything matches
    if (_locales.isEmpty()) return _LOCALE_UNKNOWN_MATCH;

    // On the other hand, if the client-locale is not specified,
    // but we do have a locale specified, there is no match.
    if (locale == null) return 0;

    int match = 0;

    for (Locale tmpLocale : _locales) {
      if (tmpLocale.getLanguage().equals(locale.getLanguage())) {
        if (tmpLocale.getCountry().equals(locale.getCountry())) {
          match = _LOCALE_EXACT_MATCH;
          break;
        }

        // If we've got a partial match, keep looking - we may could find
        // an exact match
        match = _LOCALE_PARTIAL_MATCH;
      }
    }

    return match;
  }
 public int a(Locale paramLocale1, Locale paramLocale2) {
   if (paramLocale1.equals(paramLocale2)) {
     return 0;
   }
   return String.valueOf(paramLocale1.getLanguage())
       .compareToIgnoreCase(String.valueOf(paramLocale2.getLanguage()));
 }
Exemple #15
0
  private InputStream getHelpStream(Class c, String suffix) {
    Locale locale = Stapler.getCurrentRequest().getLocale();
    String base = c.getName().replace('.', '/').replace('$', '/') + "/help" + suffix;

    ClassLoader cl = c.getClassLoader();
    if (cl == null) return null;

    InputStream in;
    in =
        cl.getResourceAsStream(
            base
                + '_'
                + locale.getLanguage()
                + '_'
                + locale.getCountry()
                + '_'
                + locale.getVariant()
                + ".html");
    if (in != null) return in;
    in =
        cl.getResourceAsStream(
            base + '_' + locale.getLanguage() + '_' + locale.getCountry() + ".html");
    if (in != null) return in;
    in = cl.getResourceAsStream(base + '_' + locale.getLanguage() + ".html");
    if (in != null) return in;

    // default
    return cl.getResourceAsStream(base + ".html");
  }
 /** @param reallyRemoveIt true: really remove it; false: dry run, only produce logging */
 public void removeXKeysTask(boolean reallyRemoveIt) {
   List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
   Set<String> allLangs = getAllLanguages();
   int counter = 0;
   for (String langKey : allLangs) {
     Locale locale = i18nMgr.getLocaleOrNull(langKey);
     for (String bundleName : allBundles) {
       Properties properties =
           i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
       Set<Object> keys = properties.keySet();
       for (Object keyObj : keys) {
         String key = (String) keyObj;
         if (key.endsWith("X")) {
           String value = properties.getProperty(key);
           if (StringHelper.containsNonWhitespace(value)) {
             log.warn(
                 "NONEMPTY XKEY detected in lang::"
                     + locale.getLanguage()
                     + " bundle::"
                     + bundleName
                     + " key::"
                     + key
                     + " value::"
                     + value);
             if (reallyRemoveIt) {
               addKey(locale, bundleName, key.substring(0, key.length() - 1), value);
             }
           }
           log.info(
               "XKEY detected in lang::"
                   + locale.getLanguage()
                   + " bundle::"
                   + bundleName
                   + " key::"
                   + key);
           logText.append(
               i18nMgr.getPropertiesFile(
                       locale, bundleName, I18nModule.getPropertyFilesBaseDir(locale, bundleName))
                   + " XKEY detected in lang::"
                   + locale.getLanguage()
                   + " bundle::"
                   + bundleName
                   + " key::"
                   + key
                   + " value::"
                   + value
                   + "\n");
           if (reallyRemoveIt) {
             deleteKey(locale, bundleName, key);
           }
           counter++;
         }
       }
     }
   }
   if (reallyRemoveIt) {
     log.info(counter + " X-Keys got removed!");
   }
 }
  /**
   * Get the appropriate localized version of a file according to language settings e. g. help files
   * in jsp/help/
   *
   * @param locale Locale to get the file for
   * @param fileName String fileName, to get the localized file for
   * @param fileType String file extension
   * @return localizedFileName String - localized filename
   */
  private static String getFilename(Locale locale, String fileName, String fileType) {
    String localizedFileName = null;
    boolean fileFound = false;
    // with Language, Country, Variant
    String fileNameLCV = null;
    // with Language, Country
    String fileNameLC = null;
    // with Language
    String fileNameL = null;
    fileNameL = fileName + "_" + locale.getLanguage();

    if (fileType == null) {
      fileType = "";
    }

    if (!("".equals(locale.getCountry()))) {
      fileNameLC = fileName + "_" + locale.getLanguage() + "_" + locale.getCountry();

      if (!("".equals(locale.getVariant()))) {
        fileNameLCV =
            fileName
                + "_"
                + locale.getLanguage()
                + "_"
                + locale.getCountry()
                + "_"
                + locale.getVariant();
      }
    }

    if (fileNameLCV != null && !fileFound) {
      File fileTmp = new File(fileNameLCV + fileType);
      if (fileTmp.exists()) {
        fileFound = true;
        localizedFileName = fileNameLCV + fileType;
      }
    }

    if (fileNameLC != null && !fileFound) {
      File fileTmp = new File(fileNameLC + fileType);
      if (fileTmp.exists()) {
        fileFound = true;
        localizedFileName = fileNameLC + fileType;
      }
    }

    if (fileNameL != null && !fileFound) {
      File fileTmp = new File(fileNameL + fileType);
      if (fileTmp.exists()) {
        fileFound = true;
        localizedFileName = fileNameL + fileType;
      }
    }
    if (!fileFound) {
      localizedFileName = fileName + fileType;
    }
    return localizedFileName;
  }
 /** @param reallyRemoveIt true: really remove it; false: dry run, only produce logging */
 public void removeTodoKeysTask(boolean reallyRemoveIt) {
   List<String> allBundles = I18nModule.getBundleNamesContainingI18nFiles();
   Set<String> allLangs = getAllLanguages();
   int counter = 0;
   String[] comparisonStrings = {"TODO"};
   for (String langKey : allLangs) {
     Locale locale = i18nMgr.getLocaleOrNull(langKey);
     for (String bundleName : allBundles) {
       Properties properties =
           i18nMgr.getPropertiesWithoutResolvingRecursively(locale, bundleName);
       Set<Object> keys = properties.keySet();
       for (Object keyObj : keys) {
         String key = (String) keyObj;
         String value = properties.getProperty(key);
         for (int i = 0; i < comparisonStrings.length; i++) {
           int pos = value.toLowerCase().indexOf(comparisonStrings[i].toLowerCase());
           if (pos != -1 && pos < 2 && !value.toLowerCase().equals("todos")) {
             log.info(
                 "TODO-Key detected in lang::"
                     + locale.getLanguage()
                     + " bundle::"
                     + bundleName
                     + " key::"
                     + key
                     + " value::"
                     + value);
             if (value.length() > comparisonStrings[i].length() + 1) {
               log.warn(
                   "this is a TODO-Key WITH TEXT::"
                       + value.substring(comparisonStrings[i].length())
                       + "::");
             } else {
               logText.append(
                   i18nMgr.getPropertiesFile(
                           locale,
                           bundleName,
                           I18nModule.getPropertyFilesBaseDir(locale, bundleName))
                       + " TODO-Key detected in lang::"
                       + locale.getLanguage()
                       + " bundle::"
                       + bundleName
                       + " key::"
                       + key
                       + " value::"
                       + value
                       + "\n");
               if (reallyRemoveIt) {
                 deleteKey(locale, bundleName, key);
               }
             }
             counter++;
           }
         }
       } // each key
     } // each bundle
   }
   log.info(counter + " TODO-Keys got removed!");
 }
 @Test
 public void testListAllSerbianCountries() {
   for (final Locale aLocale :
       CollectionHelper.getSorted(Locale.getAvailableLocales(), new ComparatorLocale()))
     if (aLocale.getLanguage().equals("sr")
         || aLocale.getLanguage().equals("sh")
         || aLocale.getLanguage().equals("bs"))
       s_aLogger.info(aLocale.toString() + ": " + aLocale.getDisplayName());
 }
Exemple #20
0
 private boolean isAvailableLocale(Locale locale) {
   String language = locale.getLanguage();
   for (Locale availableLocale : getAvailableLocales()) {
     String availableLanguage = availableLocale.getLanguage();
     if (language.equals(availableLanguage)) {
       return true;
     }
   }
   return false;
 }
 private Language parseLocaleToLanguage(Locale locale) {
   Language language = null;
   try {
     language = Language.valueOf(locale.getLanguage().toUpperCase());
   } catch (Exception e) {
     logger.error(
         "Could not parse " + locale.getLanguage() + " to a language in the Language enum.");
   }
   return language;
 }
 /**
  * Compatible is a looser matching than that provided by Locale.equals(). Two locales are
  * considered equal if they are equal, or if either does not have a country specified and the
  * languages match.
  *
  * @param lhs left hand side Locale
  * @param rhs right hand side Locale
  * @return true if the two locales are compatible, false otherwise
  * @should confirm different language missing country as compatible
  * @should confirm same language missing country as compatible
  * @should not confirm different country as compatible
  * @should confirm matching country as compatible
  * @should not confirm different language as compatible
  * @should confirm matching language as compatible
  */
 public static boolean areCompatible(Locale lhs, Locale rhs) {
   if (lhs.equals(rhs)) {
     return true;
   } else if ((lhs.getCountry() == "") || (rhs.getCountry() == "")) {
     // no country specified, so language match is good enough
     if (lhs.getLanguage().equals(rhs.getLanguage())) {
       return true;
     }
   }
   return false;
 }
Exemple #23
0
 public String toString(final Locale locale) {
   if (locale == null) {
     return null;
   }
   final String variant = locale.getVariant();
   if (StringUtils.isEmpty(variant)) {
     return locale.getLanguage() + "_" + locale.getCountry();
   } else {
     return locale.getLanguage() + "_" + locale.getCountry() + "_" + locale.getVariant();
   }
 }
  /** {@inheritDoc} */
  @Override
  public void loadLocale(Locale l) throws NoSuchLocalizationException {
    messages.remove(l);

    InputStream resstream = null;
    InputStream filestream = null;

    try {
      filestream = new FileInputStream(new File(plugin.getDataFolder(), l.getLanguage() + ".yml"));
    } catch (FileNotFoundException e) {
    }

    try {
      resstream =
          plugin.getResource(
              new StringBuilder(LOCALIZATION_FOLDER_NAME)
                  .append("/")
                  .append(l.getLanguage())
                  .append(".yml")
                  .toString());
    } catch (Exception e) {
    }

    if ((resstream == null) && (filestream == null)) throw new NoSuchLocalizationException(l);

    messages.put(l, new HashMap<Message, List<String>>(Message.values().length));

    FileConfiguration resconfig =
        (resstream == null) ? null : YamlConfiguration.loadConfiguration(resstream);
    FileConfiguration fileconfig =
        (filestream == null) ? null : YamlConfiguration.loadConfiguration(filestream);
    for (Message m : Message.values()) {
      List<String> values = m.getDefault();

      if (resconfig != null) {
        if (resconfig.isList(m.toString())) {
          values = resconfig.getStringList(m.toString());
        } else {
          values.add(resconfig.getString(m.toString(), values.get(0)));
        }
      }
      if (fileconfig != null) {
        if (fileconfig.isList(m.toString())) {
          values = fileconfig.getStringList(m.toString());
        } else {
          values.add(fileconfig.getString(m.toString(), values.get(0)));
        }
      }

      messages.get(l).put(m, values);
    }
  }
Exemple #25
0
 /**
  * Test for lax Locale equality. More precisely, returns true if (a) both are equal; (b) general
  * only specifies language, and specific has the same language; (c) general specifies language and
  * country, and specific has the same language and country. Else returns false.
  */
 public static boolean subsumes(Locale general, Locale specific) {
   if (general == null || specific == null) return false;
   if (general.equals(specific)) return true;
   else if (general.getVariant().equals("")) {
     if (general.getCountry().equals("")) {
       if (general.getLanguage().equals(specific.getLanguage())) return true;
     } else {
       if (general.getLanguage().equals(specific.getLanguage())
           && general.getCountry().equals(specific.getCountry())) return true;
     }
   }
   return false;
 }
 @RequestMapping(value = "/user/changePassword", method = RequestMethod.GET)
 public String showChangePasswordPage(
     final Locale locale,
     final Model model,
     @RequestParam("id") final long id,
     @RequestParam("token") final String token) {
   final String result = securityUserService.validatePasswordResetToken(id, token);
   if (result != null) {
     model.addAttribute("message", messages.getMessage("auth.message." + result, null, locale));
     return "redirect:/login?lang=" + locale.getLanguage();
   }
   return "redirect:/updatePassword.html?lang=" + locale.getLanguage();
 }
  /**
   * Return the resource file suffic for the indicated locale For most locales, this will be based
   * the language code. However for Chinese, we do distinguish between Taiwan and PRC
   *
   * @param locale the locale
   * @return an String suffix which canbe appended to a resource name
   */
  private static final String getResourceSuffix(Locale locale) {

    String lang = locale.getLanguage();
    String country = locale.getCountry();
    String variant = locale.getVariant();
    String suffix = "_" + locale.getLanguage();

    if (lang.equals("zh")) suffix += "_" + country;

    if (country.equals("JP")) suffix += "_" + country + "_" + variant;

    return suffix;
  }
  /*
   * Gets the resource bundle with the given base name and preferred locale.
   *
   * This method calls java.util.ResourceBundle.getBundle(), but ignores
   * its return value unless its locale represents an exact or language match
   * with the given preferred locale.
   *
   * @param basename the resource bundle base name
   * @param pref the preferred locale
   *
   * @return the requested resource bundle, or <tt>null</tt> if no resource
   * bundle with the given base name exists or if there is no exact- or
   * language-match between the preferred locale and the locale of
   * the bundle returned by java.util.ResourceBundle.getBundle().
   */
  private static ResourceBundle findMatch(String basename, Locale pref) {
    ResourceBundle match = null;

    try {
      ResourceBundle bundle =
          ResourceBundle.getBundle(basename, pref, Thread.currentThread().getContextClassLoader());
      Locale avail = bundle.getLocale();
      if (pref.equals(avail)) {
        // Exact match
        match = bundle;
      } else {
        /*
         * We have to make sure that the match we got is for
         * the specified locale. The way ResourceBundle.getBundle()
         * works, if a match is not found with (1) the specified locale,
         * it tries to match with (2) the current default locale as
         * returned by Locale.getDefault() or (3) the root resource
         * bundle (basename).
         * We must ignore any match that could have worked with (2) or (3).
         * So if an exact match is not found, we make the following extra
         * tests:
         *     - avail locale must be equal to preferred locale
         *     - avail country must be empty or equal to preferred country
         *       (the equality match might have failed on the variant)
         */
        if (pref.getLanguage().equals(avail.getLanguage())
            && ("".equals(avail.getCountry()) || pref.getCountry().equals(avail.getCountry()))) {
          /*
           * Language match.
           * By making sure the available locale does not have a
           * country and matches the preferred locale's language, we
           * rule out "matches" based on the container's default
           * locale. For example, if the preferred locale is
           * "en-US", the container's default locale is "en-UK", and
           * there is a resource bundle (with the requested base
           * name) available for "en-UK", ResourceBundle.getBundle()
           * will return it, but even though its language matches
           * that of the preferred locale, we must ignore it,
           * because matches based on the container's default locale
           * are not portable across different containers with
           * different default locales.
           */
          match = bundle;
        }
      }
    } catch (MissingResourceException mre) {
    }

    return match;
  }
 /**
  * Return the default date pattern for this application.<br>
  * If the locale is not null then uses the format associated with this specific locale if it
  * exists
  *
  * @param locale a {@link Locale}
  * @return a String pattern
  */
 public static String getDefaultDatePattern(Locale locale) {
   if (locale == null) {
     return getDefaultDatePattern();
   }
   if (Play.application()
       .configuration()
       .keys()
       .contains("maf.default.date.format." + locale.getLanguage())) {
     return Play.application()
         .configuration()
         .getString("maf.default.date.format." + locale.getLanguage());
   }
   return getDefaultDatePattern();
 }
 public void testLocaleTokenizer() {
   try {
     I18NTokenizer tok = new I18NTokenizer(HEADER);
     Locale locale = (Locale) tok.next();
     assertEquals("Either wrong language or order parsing: " + locale, locale.getLanguage(), "en");
     locale = (Locale) tok.next();
     assertEquals("Either wrong language or order parsing: " + locale, locale.getLanguage(), "es");
     locale = (Locale) tok.next();
     assertEquals("Either wrong country or order parsing: " + locale, locale.getCountry(), "TW");
   } catch (Exception e) {
     e.printStackTrace();
     fail();
   }
 }