| /* |
| * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package build.tools.cldrconverter; |
| |
| import java.io.IOException; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.EnumSet; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Optional; |
| import java.util.stream.Collectors; |
| import java.util.stream.IntStream; |
| |
| class Bundle { |
| static enum Type { |
| LOCALENAMES, CURRENCYNAMES, TIMEZONENAMES, CALENDARDATA, FORMATDATA; |
| |
| static EnumSet<Type> ALL_TYPES = EnumSet.of(LOCALENAMES, |
| CURRENCYNAMES, |
| TIMEZONENAMES, |
| CALENDARDATA, |
| FORMATDATA); |
| } |
| |
| private static final Map<String, Bundle> bundles = new HashMap<>(); |
| |
| private static final String[] NUMBER_PATTERN_KEYS = { |
| "NumberPatterns/decimal", |
| "NumberPatterns/currency", |
| "NumberPatterns/percent", |
| "NumberPatterns/accounting" |
| }; |
| |
| private static final String[] COMPACT_NUMBER_PATTERN_KEYS = { |
| "short.CompactNumberPatterns", |
| "long.CompactNumberPatterns" |
| }; |
| |
| private static final String[] NUMBER_ELEMENT_KEYS = { |
| "NumberElements/decimal", |
| "NumberElements/group", |
| "NumberElements/list", |
| "NumberElements/percent", |
| "NumberElements/zero", |
| "NumberElements/pattern", |
| "NumberElements/minus", |
| "NumberElements/exponential", |
| "NumberElements/permille", |
| "NumberElements/infinity", |
| "NumberElements/nan", |
| "NumberElements/currencyDecimal", |
| "NumberElements/currencyGroup", |
| }; |
| |
| private static final String[] TIME_PATTERN_KEYS = { |
| "DateTimePatterns/full-time", |
| "DateTimePatterns/long-time", |
| "DateTimePatterns/medium-time", |
| "DateTimePatterns/short-time", |
| }; |
| |
| private static final String[] DATE_PATTERN_KEYS = { |
| "DateTimePatterns/full-date", |
| "DateTimePatterns/long-date", |
| "DateTimePatterns/medium-date", |
| "DateTimePatterns/short-date", |
| }; |
| |
| private static final String[] DATETIME_PATTERN_KEYS = { |
| "DateTimePatterns/full-dateTime", |
| "DateTimePatterns/long-dateTime", |
| "DateTimePatterns/medium-dateTime", |
| "DateTimePatterns/short-dateTime", |
| }; |
| |
| private static final String[] ERA_KEYS = { |
| "long.Eras", |
| "Eras", |
| "narrow.Eras" |
| }; |
| |
| static final String[] LIST_PATTERN_KEYS = { |
| "ListPatterns_standard", |
| "ListPatterns_or", |
| "ListPatterns_unit", |
| }; |
| |
| // DateFormatItem prefix |
| static final String DATEFORMATITEM_KEY_PREFIX = "DateFormatItem."; |
| static final String DATEFORMATITEM_INPUT_REGIONS_PREFIX = "DateFormatItemInputRegions."; |
| |
| // Keys for individual time zone names |
| private static final String TZ_GEN_LONG_KEY = "timezone.displayname.generic.long"; |
| private static final String TZ_GEN_SHORT_KEY = "timezone.displayname.generic.short"; |
| private static final String TZ_STD_LONG_KEY = "timezone.displayname.standard.long"; |
| private static final String TZ_STD_SHORT_KEY = "timezone.displayname.standard.short"; |
| private static final String TZ_DST_LONG_KEY = "timezone.displayname.daylight.long"; |
| private static final String TZ_DST_SHORT_KEY = "timezone.displayname.daylight.short"; |
| private static final String[] ZONE_NAME_KEYS = { |
| TZ_STD_LONG_KEY, |
| TZ_STD_SHORT_KEY, |
| TZ_DST_LONG_KEY, |
| TZ_DST_SHORT_KEY, |
| TZ_GEN_LONG_KEY, |
| TZ_GEN_SHORT_KEY |
| }; |
| |
| private final String id; |
| private final String cldrPath; |
| private final EnumSet<Type> bundleTypes; |
| private final String currencies; |
| private Map<String, Object> targetMap; |
| |
| static Bundle getBundle(String id) { |
| return bundles.get(id); |
| } |
| |
| @SuppressWarnings("ConvertToStringSwitch") |
| Bundle(String id, String cldrPath, String bundles, String currencies) { |
| this.id = id; |
| this.cldrPath = cldrPath; |
| if ("localenames".equals(bundles)) { |
| bundleTypes = EnumSet.of(Type.LOCALENAMES); |
| } else if ("currencynames".equals(bundles)) { |
| bundleTypes = EnumSet.of(Type.CURRENCYNAMES); |
| } else { |
| bundleTypes = Type.ALL_TYPES; |
| } |
| if (currencies == null) { |
| currencies = "local"; |
| } |
| this.currencies = currencies; |
| addBundle(); |
| } |
| |
| private void addBundle() { |
| Bundle.bundles.put(id, this); |
| } |
| |
| String getID() { |
| return id; |
| } |
| |
| boolean isRoot() { |
| return "root".equals(id); |
| } |
| |
| String getCLDRPath() { |
| return cldrPath; |
| } |
| |
| EnumSet<Type> getBundleTypes() { |
| return bundleTypes; |
| } |
| |
| String getCurrencies() { |
| return currencies; |
| } |
| |
| /** |
| * Generate a map that contains all the data that should be |
| * visible for the bundle's locale |
| */ |
| Map<String, Object> getTargetMap() throws Exception { |
| if (targetMap != null) { |
| return targetMap; |
| } |
| |
| String[] cldrBundles = getCLDRPath().split(","); |
| |
| // myMap contains resources for id. |
| Map<String, Object> myMap = new HashMap<>(); |
| int index; |
| for (index = 0; index < cldrBundles.length; index++) { |
| if (cldrBundles[index].equals(id)) { |
| myMap.putAll(CLDRConverter.getCLDRBundle(cldrBundles[index])); |
| break; |
| } |
| } |
| |
| // parentsMap contains resources from id's parents. |
| Map<String, Object> parentsMap = new HashMap<>(); |
| for (int i = cldrBundles.length - 1; i > index; i--) { |
| parentsMap.putAll(CLDRConverter.getCLDRBundle(cldrBundles[i])); |
| } |
| // Duplicate myMap as parentsMap for "root" so that the |
| // fallback works. This is a hack, though. |
| if ("root".equals(cldrBundles[0])) { |
| assert parentsMap.isEmpty(); |
| parentsMap.putAll(myMap); |
| } |
| |
| // merge individual strings into arrays |
| |
| // if myMap has any of the NumberPatterns/NumberElements members, create a |
| // complete array of patterns/elements. |
| @SuppressWarnings("unchecked") |
| List<String> scripts = (List<String>) myMap.get("numberingScripts"); |
| if (scripts != null) { |
| for (String script : scripts) { |
| myMap.put(script + ".NumberPatterns", |
| createNumberArray(myMap, parentsMap, NUMBER_PATTERN_KEYS, script)); |
| myMap.put(script + ".NumberElements", |
| createNumberArray(myMap, parentsMap, NUMBER_ELEMENT_KEYS, script)); |
| } |
| } |
| |
| for (String k : COMPACT_NUMBER_PATTERN_KEYS) { |
| @SuppressWarnings("unchecked") |
| List<String> patterns = (List<String>) myMap.remove(k); |
| if (patterns != null) { |
| // Convert the map value from List<String> to String[], replacing any missing |
| // entry from the parents map, if any. |
| @SuppressWarnings("unchecked") |
| final List<String> pList = (List<String>)parentsMap.get(k); |
| int size = patterns.size(); |
| int psize = pList != null ? pList.size() : 0; |
| String[] arrPatterns = IntStream.range(0, Math.max(size, psize)) |
| .mapToObj(i -> { |
| String pattern; |
| // first try itself. |
| if (i < size) { |
| pattern = patterns.get(i); |
| if (!pattern.isEmpty()) { |
| return "{" + pattern + "}"; |
| } |
| } |
| // if not found, try parent |
| if (i < psize) { |
| pattern = pList.get(i); |
| if (!pattern.isEmpty()) { |
| return "{" + pattern + "}"; |
| } |
| } |
| // bail out with empty string |
| return ""; |
| }) |
| .toArray(String[]::new); |
| myMap.put(k, arrPatterns); |
| } |
| } |
| |
| // Processes aliases here |
| CLDRConverter.handleAliases(myMap); |
| |
| // another hack: parentsMap is not used for date-time resources. |
| if (isRoot()) { |
| parentsMap = null; |
| } |
| |
| for (CalendarType calendarType : CalendarType.values()) { |
| String calendarPrefix = calendarType.keyElementName(); |
| // handle multiple inheritance for month and day names |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "MonthNames"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "MonthAbbreviations"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "MonthNarrows"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "DayNames"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "DayAbbreviations"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "DayNarrows"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "AmPmMarkers"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "narrow.AmPmMarkers"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "abbreviated.AmPmMarkers"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "QuarterNames"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "QuarterAbbreviations"); |
| handleMultipleInheritance(myMap, parentsMap, calendarPrefix + "QuarterNarrows"); |
| |
| adjustEraNames(myMap, parentsMap, calendarType); |
| |
| handleDateTimeFormatPatterns(TIME_PATTERN_KEYS, myMap, parentsMap, calendarType, "TimePatterns"); |
| handleDateTimeFormatPatterns(DATE_PATTERN_KEYS, myMap, parentsMap, calendarType, "DatePatterns"); |
| handleDateTimeFormatPatterns(DATETIME_PATTERN_KEYS, myMap, parentsMap, calendarType, "DateTimePatterns"); |
| |
| // Skeleton |
| handleSkeletonPatterns(myMap, calendarType); |
| } |
| |
| // Skeleton input regions |
| if (isRoot()) { |
| skeletonInputRegions(myMap); |
| } |
| |
| // First, weed out any empty timezone or metazone names from myMap. |
| for (Iterator<String> it = myMap.keySet().iterator(); it.hasNext();) { |
| String key = it.next(); |
| if (key.startsWith(CLDRConverter.TIMEZONE_ID_PREFIX) |
| || key.startsWith(CLDRConverter.METAZONE_ID_PREFIX)) { |
| @SuppressWarnings("unchecked") |
| Map<String, String> nameMap = (Map<String, String>) myMap.get(key); |
| if (nameMap.isEmpty()) { |
| // Some zones have only exemplarCity, which become empty. |
| // Remove those from the map. |
| it.remove(); |
| continue; |
| } |
| } |
| } |
| for (Iterator<String> it = myMap.keySet().iterator(); it.hasNext();) { |
| String key = it.next(); |
| if (key.startsWith(CLDRConverter.TIMEZONE_ID_PREFIX) |
| || key.startsWith(CLDRConverter.METAZONE_ID_PREFIX)) { |
| @SuppressWarnings("unchecked") |
| Map<String, String> nameMap = (Map<String, String>) myMap.get(key); |
| |
| // Convert key/value pairs to an array. |
| String[] names = new String[ZONE_NAME_KEYS.length]; |
| int ix = 0; |
| for (String nameKey : ZONE_NAME_KEYS) { |
| String name = nameMap.get(nameKey); |
| if (name == null && parentsMap != null) { |
| @SuppressWarnings("unchecked") |
| Map<String, String> parentNames = (Map<String, String>) parentsMap.get(key); |
| if (parentNames != null) { |
| name = parentNames.get(nameKey); |
| } |
| } |
| names[ix++] = name; |
| } |
| if (hasNulls(names)) { |
| String metaKey = toMetaZoneKey(key); |
| if (metaKey != null) { |
| Object obj = myMap.get(metaKey); |
| if (obj instanceof String[]) { |
| String[] metaNames = (String[]) obj; |
| for (int i = 0; i < names.length; i++) { |
| if (names[i] == null) { |
| names[i] = metaNames[i]; |
| } |
| } |
| } else if (obj instanceof Map) { |
| @SuppressWarnings("unchecked") |
| Map<String, String> m = (Map<String, String>) obj; |
| for (int i = 0; i < names.length; i++) { |
| if (names[i] == null) { |
| names[i] = m.get(ZONE_NAME_KEYS[i]); |
| } |
| } |
| } |
| } |
| } |
| // replace the Map with the array |
| if (names != null) { |
| myMap.put(key, names); |
| } else { |
| it.remove(); |
| } |
| } |
| } |
| // replace empty era names with parentMap era names |
| for (String key : ERA_KEYS) { |
| Object value = myMap.get(key); |
| if (value != null && value instanceof String[]) { |
| String[] eraStrings = (String[]) value; |
| for (String eraString : eraStrings) { |
| if (eraString == null || eraString.isEmpty()) { |
| fillInElements(parentsMap, key, value); |
| } |
| } |
| } |
| } |
| |
| // rules |
| String rule = CLDRConverter.pluralRules.get(id); |
| if (rule != null) { |
| myMap.put("PluralRules", rule); |
| } |
| rule = CLDRConverter.dayPeriodRules.get(id); |
| if (rule != null) { |
| myMap.put("DayPeriodRules", rule); |
| } |
| |
| // Remove all duplicates |
| if (Objects.nonNull(parentsMap)) { |
| for (Iterator<String> it = myMap.keySet().iterator(); it.hasNext();) { |
| String key = it.next(); |
| if (!key.equals("numberingScripts") && // real body "NumberElements" may differ |
| Objects.deepEquals(parentsMap.get(key), myMap.get(key))) { |
| it.remove(); |
| } |
| } |
| } |
| |
| targetMap = myMap; |
| return myMap; |
| } |
| |
| private void handleMultipleInheritance(Map<String, Object> map, Map<String, Object> parents, String key) { |
| String formatMapKey = key + "/format"; |
| Object format = map.get(formatMapKey); |
| if (format != null) { |
| map.remove(formatMapKey); |
| map.put(key, format); |
| if (fillInElements(parents, formatMapKey, format)) { |
| map.remove(key); |
| } |
| } |
| String standaloneMapKey = key + "/stand-alone"; |
| Object standalone = map.get(standaloneMapKey); |
| if (standalone != null) { |
| map.remove(standaloneMapKey); |
| String standaloneResourceKey = "standalone." + key; |
| map.put(standaloneResourceKey, standalone); |
| if (fillInElements(parents, standaloneMapKey, standalone)) { |
| map.remove(standaloneResourceKey); |
| } |
| } |
| } |
| |
| /** |
| * Fills in any empty elements with its parent element, falling back to |
| * aliased one if parent element is not found. Returns true if the resulting |
| * array is identical to its parent array. |
| * |
| * @param parents |
| * @param key |
| * @param value |
| * @return true if the resulting array is identical to its parent array. |
| */ |
| private boolean fillInElements(Map<String, Object> parents, String key, Object value) { |
| if (parents == null) { |
| return false; |
| } |
| if (value instanceof String[]) { |
| Object pvalue = parents.getOrDefault(key, parents.get(CLDRConverter.aliases.get(key))); |
| if (pvalue != null && pvalue instanceof String[]) { |
| String[] strings = (String[]) value; |
| String[] pstrings = (String[]) pvalue; |
| for (int i = 0; i < strings.length; i++) { |
| if (strings[i] == null || strings[i].length() == 0) { |
| strings[i] = pstrings[i]; |
| } |
| } |
| return Arrays.equals(strings, pstrings); |
| } |
| } |
| return false; |
| } |
| |
| /* |
| * Adjusts String[] for era names because JRE's Calendars use different |
| * ERA value indexes in the Buddhist, Japanese Imperial, and Islamic calendars. |
| */ |
| private void adjustEraNames(Map<String, Object> map, Map<String, Object> pMap, CalendarType type) { |
| String[][] eraNames = new String[ERA_KEYS.length][]; |
| String[] realKeys = new String[ERA_KEYS.length]; |
| int index = 0; |
| for (String key : ERA_KEYS) { |
| String realKey = type.keyElementName() + key; |
| String[] value = (String[]) map.get(realKey); |
| if (value != null) { |
| // first fill in missing elements from parents map. |
| fillInElements(pMap, realKey, value); |
| |
| switch (type) { |
| case GREGORIAN: |
| break; |
| |
| case JAPANESE: |
| { |
| String[] newValue = new String[value.length + 1]; |
| String[] julianEras = (String[]) map.get(key); |
| if (julianEras != null && julianEras.length >= 2) { |
| newValue[0] = julianEras[1]; |
| } else { |
| newValue[0] = ""; |
| } |
| System.arraycopy(value, 0, newValue, 1, value.length); |
| value = newValue; |
| |
| // fix up 'Reiwa' era, which can be missing in some locales |
| if (value[value.length - 1] == null) { |
| value[value.length - 1] = (key.startsWith("narrow.") ? "R" : "Reiwa"); |
| } |
| } |
| break; |
| |
| case BUDDHIST: |
| // Replace the value |
| value = new String[] {"BC", value[0]}; |
| break; |
| |
| case ISLAMIC: |
| // Replace the value |
| value = new String[] {"", value[0]}; |
| break; |
| } |
| map.put(realKey, value); |
| map.put("java.time." + realKey, value); |
| } |
| realKeys[index] = realKey; |
| eraNames[index++] = value; |
| } |
| for (int i = 0; i < eraNames.length; i++) { |
| if (eraNames[i] == null) { |
| map.put(realKeys[i], null); |
| } |
| } |
| } |
| |
| private void handleDateTimeFormatPatterns(String[] patternKeys, Map<String, Object> myMap, Map<String, Object> parentsMap, |
| CalendarType calendarType, String name) { |
| String calendarPrefix = calendarType.keyElementName(); |
| for (String k : patternKeys) { |
| if (myMap.containsKey(calendarPrefix + k)) { |
| int len = patternKeys.length; |
| List<String> dateTimePatterns = new ArrayList<>(len); |
| List<String> sdfPatterns = new ArrayList<>(len); |
| for (int i = 0; i < len; i++) { |
| String key = calendarPrefix + patternKeys[i]; |
| String pattern = (String) myMap.remove(key); |
| if (pattern == null) { |
| pattern = (String) parentsMap.remove(key); |
| } |
| if (pattern != null) { |
| // Perform date-time format pattern conversion which is |
| // applicable to both SimpleDateFormat and j.t.f.DateTimeFormatter. |
| String transPattern = translateDateFormatLetters(calendarType, key, pattern, this::convertDateTimePatternLetter); |
| dateTimePatterns.add(i, transPattern); |
| // Additionally, perform SDF specific date-time format pattern conversion |
| sdfPatterns.add(i, translateDateFormatLetters(calendarType, key, transPattern, this::convertSDFLetter)); |
| } else { |
| dateTimePatterns.add(i, null); |
| sdfPatterns.add(i, null); |
| } |
| } |
| // If empty, discard patterns |
| if (sdfPatterns.isEmpty()) { |
| return; |
| } |
| String key = calendarPrefix + name; |
| |
| // If additional changes are made in the SDF specific conversion, |
| // keep the commonly converted patterns as java.time patterns |
| if (!dateTimePatterns.equals(sdfPatterns)) { |
| myMap.put("java.time." + key, dateTimePatterns.toArray(String[]::new)); |
| } |
| myMap.put(key, sdfPatterns.toArray(new String[len])); |
| break; |
| } |
| } |
| } |
| |
| private String translateDateFormatLetters(CalendarType calendarType, String patternKey, String cldrFormat, ConvertDateTimeLetters converter) { |
| String pattern = cldrFormat; |
| int length = pattern.length(); |
| boolean inQuote = false; |
| StringBuilder jrePattern = new StringBuilder(length); |
| int count = 0; |
| char lastLetter = 0; |
| |
| for (int i = 0; i < length; i++) { |
| char c = pattern.charAt(i); |
| |
| if (c == '\'') { |
| // '' is treated as a single quote regardless of being |
| // in a quoted section. |
| if ((i + 1) < length) { |
| char nextc = pattern.charAt(i + 1); |
| if (nextc == '\'') { |
| i++; |
| if (count != 0) { |
| converter.convert(calendarType, patternKey, lastLetter, count, jrePattern); |
| lastLetter = 0; |
| count = 0; |
| } |
| jrePattern.append("''"); |
| continue; |
| } |
| } |
| if (!inQuote) { |
| if (count != 0) { |
| converter.convert(calendarType, patternKey, lastLetter, count, jrePattern); |
| lastLetter = 0; |
| count = 0; |
| } |
| inQuote = true; |
| } else { |
| inQuote = false; |
| } |
| jrePattern.append(c); |
| continue; |
| } |
| if (inQuote) { |
| jrePattern.append(c); |
| continue; |
| } |
| if (!(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')) { |
| if (count != 0) { |
| converter.convert(calendarType, patternKey, lastLetter, count, jrePattern); |
| lastLetter = 0; |
| count = 0; |
| } |
| jrePattern.append(c); |
| continue; |
| } |
| |
| if (lastLetter == 0 || lastLetter == c) { |
| lastLetter = c; |
| count++; |
| continue; |
| } |
| converter.convert(calendarType, patternKey, lastLetter, count, jrePattern); |
| lastLetter = c; |
| count = 1; |
| } |
| |
| if (inQuote) { |
| throw new InternalError("Unterminated quote in date-time pattern: " + cldrFormat); |
| } |
| |
| if (count != 0) { |
| converter.convert(calendarType, patternKey, lastLetter, count, jrePattern); |
| } |
| if (cldrFormat.contentEquals(jrePattern)) { |
| return cldrFormat; |
| } |
| return jrePattern.toString(); |
| } |
| |
| private String toMetaZoneKey(String tzKey) { |
| if (tzKey.startsWith(CLDRConverter.TIMEZONE_ID_PREFIX)) { |
| String tz = tzKey.substring(CLDRConverter.TIMEZONE_ID_PREFIX.length()); |
| String meta = CLDRConverter.handlerMetaZones.get(tz); |
| if (meta != null) { |
| return CLDRConverter.METAZONE_ID_PREFIX + meta; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Perform a generic conversion of CLDR date-time format pattern letter based |
| * on the support given by the SimpleDateFormat and the j.t.f.DateTimeFormatter |
| * for date-time formatting. |
| */ |
| private void convertDateTimePatternLetter(CalendarType calendarType, String patternKey, char cldrLetter, int count, StringBuilder sb) { |
| switch (cldrLetter) { |
| case 'u': |
| case 'U': |
| // Change cldr letter 'u'/'U' to 'y', as 'u' is interpreted as |
| // "Extended year (numeric)", and 'U' as "Cyclic year" in CLDR/LDML, |
| // which is not supported in SimpleDateFormat and |
| // j.t.f.DateTimeFormatter, so it is replaced with 'y' |
| // as the best approximation |
| appendN('y', count, sb); |
| break; |
| default: |
| appendN(cldrLetter, count, sb); |
| break; |
| |
| } |
| } |
| |
| /** |
| * Perform a conversion of CLDR date-time format pattern letter which is |
| * specific to the SimpleDateFormat. |
| */ |
| private void convertSDFLetter(CalendarType calendarType, String patternKey, char cldrLetter, int count, StringBuilder sb) { |
| switch (cldrLetter) { |
| case 'G': |
| if (calendarType != CalendarType.GREGORIAN) { |
| // Adjust the number of 'G's for JRE SimpleDateFormat |
| if (count == 5) { |
| // CLDR narrow -> JRE short |
| count = 1; |
| } else if (count == 1) { |
| // CLDR abbr -> JRE long |
| count = 4; |
| } |
| } |
| appendN(cldrLetter, count, sb); |
| break; |
| |
| // TODO: support 'c' and 'e' in JRE SimpleDateFormat |
| // Use 'u' and 'E' for now. |
| case 'c': |
| case 'e': |
| switch (count) { |
| case 1: |
| sb.append('u'); |
| break; |
| case 3: |
| case 4: |
| appendN('E', count, sb); |
| break; |
| case 5: |
| appendN('E', 3, sb); |
| break; |
| } |
| break; |
| |
| case 'v': |
| case 'V': |
| appendN('z', count, sb); |
| break; |
| |
| case 'y': |
| // If the style is FULL/LONG for a Japanese Calendar, make the |
| // count == 4 for Gan-nen |
| if (calendarType == CalendarType.JAPANESE && |
| (patternKey.contains("full-") || |
| patternKey.contains("long-"))) { |
| count = 4; |
| } |
| appendN(cldrLetter, count, sb); |
| break; |
| |
| case 'Z': |
| if (count == 4 || count == 5) { |
| sb.append("XXX"); |
| } |
| break; |
| |
| case 'B': |
| // 'B' character (day period) is not supported by SimpleDateFormat, |
| // this is a workaround in which 'B' character |
| // appearing in CLDR date-time pattern is replaced |
| // with 'a' character and hence resolved with am/pm strings. |
| // This workaround is based on the fallback mechanism |
| // specified in LDML spec for 'B' character, when a locale |
| // does not have data for day period ('B') |
| appendN('a', count, sb); |
| break; |
| |
| default: |
| appendN(cldrLetter, count, sb); |
| break; |
| } |
| } |
| |
| private void appendN(char c, int n, StringBuilder sb) { |
| for (int i = 0; i < n; i++) { |
| sb.append(c); |
| } |
| } |
| |
| private static boolean hasNulls(Object[] array) { |
| for (int i = 0; i < array.length; i++) { |
| if (array[i] == null) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void handleSkeletonPatterns(Map<String, Object> myMap, CalendarType calendarType) { |
| String calendarPrefix = calendarType.keyElementName(); |
| myMap.putAll(myMap.entrySet().stream() |
| .filter(e -> e.getKey().startsWith(Bundle.DATEFORMATITEM_KEY_PREFIX)) |
| .collect(Collectors.toMap( |
| e -> calendarPrefix + e.getKey(), |
| e -> translateDateFormatLetters(calendarType, |
| e.getKey(), |
| (String)e.getValue(), |
| this::convertDateTimePatternLetter) |
| )) |
| ); |
| } |
| |
| @FunctionalInterface |
| private interface ConvertDateTimeLetters { |
| void convert(CalendarType calendarType, String patternKey, char cldrLetter, int count, StringBuilder sb); |
| } |
| |
| /** |
| * Returns a complete string array for NumberElements or NumberPatterns. If any |
| * array element is missing, it will fall back to parents map, as well as |
| * numbering script fallback. |
| */ |
| private String[] createNumberArray(Map<String, Object> myMap, Map<String, Object>parentsMap, |
| String[] keys, String script) { |
| String[] numArray = new String[keys.length]; |
| for (int i = 0; i < keys.length; i++) { |
| String key = script + "." + keys[i]; |
| final int idx = i; |
| Optional.ofNullable( |
| myMap.getOrDefault(key, |
| // if value not found in myMap, search for parentsMap |
| parentsMap.getOrDefault(key, |
| parentsMap.getOrDefault(keys[i], |
| // the last resort is "latn" |
| parentsMap.get("latn." + keys[i]))))) |
| .ifPresentOrElse(v -> numArray[idx] = (String)v, () -> { |
| if (keys == NUMBER_PATTERN_KEYS) { |
| // NumberPatterns |
| if (!key.endsWith("accounting")) { |
| // throw error unless it is for "accounting", |
| // which may be missing. |
| throw new InternalError("NumberPatterns: null for " + |
| key + ", id: " + id); |
| } |
| } else { |
| // NumberElements |
| assert keys == NUMBER_ELEMENT_KEYS; |
| if (key.endsWith("/pattern")) { |
| numArray[idx] = "#"; |
| } else if (!key.endsWith("currencyDecimal") && |
| !key.endsWith("currencyGroup")) { |
| // throw error unless it is for "currencyDecimal/Group", |
| // which may be missing. |
| throw new InternalError("NumberElements: null for " + |
| key + ", id: " + id); |
| } |
| }}); |
| } |
| return numArray; |
| } |
| |
| private static void skeletonInputRegions(Map<String, Object> myMap) { |
| myMap.putAll(myMap.entrySet().stream() |
| .filter(e -> e.getKey().startsWith(Bundle.DATEFORMATITEM_INPUT_REGIONS_PREFIX)) |
| .collect(Collectors.toMap( |
| e -> e.getKey(), |
| e -> ((String)e.getValue()).trim() |
| )) |
| ); |
| } |
| } |
