| /* |
| ******************************************************************************* |
| * Copyright (C) 2013-2015, International Business Machines Corporation and |
| * others. All Rights Reserved. |
| ******************************************************************************* |
| */ |
| package com.ibm.icu.text; |
| |
| import java.util.EnumMap; |
| import java.util.Locale; |
| |
| import com.ibm.icu.impl.CalendarData; |
| import com.ibm.icu.impl.ICUCache; |
| import com.ibm.icu.impl.ICUResourceBundle; |
| import com.ibm.icu.impl.SimpleCache; |
| import com.ibm.icu.lang.UCharacter; |
| import com.ibm.icu.util.ULocale; |
| import com.ibm.icu.util.UResourceBundle; |
| |
| |
| /** |
| * Formats simple relative dates. There are two types of relative dates that |
| * it handles: |
| * <ul> |
| * <li>relative dates with a quantity e.g "in 5 days"</li> |
| * <li>relative dates without a quantity e.g "next Tuesday"</li> |
| * </ul> |
| * <p> |
| * This API is very basic and is intended to be a building block for more |
| * fancy APIs. The caller tells it exactly what to display in a locale |
| * independent way. While this class automatically provides the correct plural |
| * forms, the grammatical form is otherwise as neutral as possible. It is the |
| * caller's responsibility to handle cut-off logic such as deciding between |
| * displaying "in 7 days" or "in 1 week." This API supports relative dates |
| * involving one single unit. This API does not support relative dates |
| * involving compound units. |
| * e.g "in 5 days and 4 hours" nor does it support parsing. |
| * This class is both immutable and thread-safe. |
| * <p> |
| * Here are some examples of use: |
| * <blockquote> |
| * <pre> |
| * RelativeDateTimeFormatter fmt = RelativeDateTimeFormatter.getInstance(); |
| * fmt.format(1, Direction.NEXT, RelativeUnit.DAYS); // "in 1 day" |
| * fmt.format(3, Direction.NEXT, RelativeUnit.DAYS); // "in 3 days" |
| * fmt.format(3.2, Direction.LAST, RelativeUnit.YEARS); // "3.2 years ago" |
| * |
| * fmt.format(Direction.LAST, AbsoluteUnit.SUNDAY); // "last Sunday" |
| * fmt.format(Direction.THIS, AbsoluteUnit.SUNDAY); // "this Sunday" |
| * fmt.format(Direction.NEXT, AbsoluteUnit.SUNDAY); // "next Sunday" |
| * fmt.format(Direction.PLAIN, AbsoluteUnit.SUNDAY); // "Sunday" |
| * |
| * fmt.format(Direction.LAST, AbsoluteUnit.DAY); // "yesterday" |
| * fmt.format(Direction.THIS, AbsoluteUnit.DAY); // "today" |
| * fmt.format(Direction.NEXT, AbsoluteUnit.DAY); // "tomorrow" |
| * |
| * fmt.format(Direction.PLAIN, AbsoluteUnit.NOW); // "now" |
| * </pre> |
| * </blockquote> |
| * <p> |
| * In the future, we may add more forms, such as abbreviated/short forms |
| * (3 secs ago), and relative day periods ("yesterday afternoon"), etc. |
| * |
| * @stable ICU 53 |
| */ |
| public final class RelativeDateTimeFormatter { |
| |
| /** |
| * The formatting style |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| * |
| */ |
| public static enum Style { |
| |
| /** |
| * Everything spelled out. |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| LONG, |
| |
| /** |
| * Abbreviations used when possible. |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| SHORT, |
| |
| /** |
| * Use single letters when possible. |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| NARROW, |
| } |
| |
| /** |
| * Represents the unit for formatting a relative date. e.g "in 5 days" |
| * or "in 3 months" |
| * @stable ICU 53 |
| */ |
| public static enum RelativeUnit { |
| |
| /** |
| * Seconds |
| * @stable ICU 53 |
| */ |
| SECONDS, |
| |
| /** |
| * Minutes |
| * @stable ICU 53 |
| */ |
| MINUTES, |
| |
| /** |
| * Hours |
| * @stable ICU 53 |
| */ |
| HOURS, |
| |
| /** |
| * Days |
| * @stable ICU 53 |
| */ |
| DAYS, |
| |
| /** |
| * Weeks |
| * @stable ICU 53 |
| */ |
| WEEKS, |
| |
| /** |
| * Months |
| * @stable ICU 53 |
| */ |
| MONTHS, |
| |
| /** |
| * Years |
| * @stable ICU 53 |
| */ |
| YEARS, |
| } |
| |
| /** |
| * Represents an absolute unit. |
| * @stable ICU 53 |
| */ |
| public static enum AbsoluteUnit { |
| |
| /** |
| * Sunday |
| * @stable ICU 53 |
| */ |
| SUNDAY, |
| |
| /** |
| * Monday |
| * @stable ICU 53 |
| */ |
| MONDAY, |
| |
| /** |
| * Tuesday |
| * @stable ICU 53 |
| */ |
| TUESDAY, |
| |
| /** |
| * Wednesday |
| * @stable ICU 53 |
| */ |
| WEDNESDAY, |
| |
| /** |
| * Thursday |
| * @stable ICU 53 |
| */ |
| THURSDAY, |
| |
| /** |
| * Friday |
| * @stable ICU 53 |
| */ |
| FRIDAY, |
| |
| /** |
| * Saturday |
| * @stable ICU 53 |
| */ |
| SATURDAY, |
| |
| /** |
| * Day |
| * @stable ICU 53 |
| */ |
| DAY, |
| |
| /** |
| * Week |
| * @stable ICU 53 |
| */ |
| WEEK, |
| |
| /** |
| * Month |
| * @stable ICU 53 |
| */ |
| MONTH, |
| |
| /** |
| * Year |
| * @stable ICU 53 |
| */ |
| YEAR, |
| |
| /** |
| * Now |
| * @stable ICU 53 |
| */ |
| NOW, |
| } |
| |
| /** |
| * Represents a direction for an absolute unit e.g "Next Tuesday" |
| * or "Last Tuesday" |
| * @stable ICU 53 |
| */ |
| public static enum Direction { |
| |
| /** |
| * Two before. Not fully supported in every locale |
| * @stable ICU 53 |
| */ |
| LAST_2, |
| |
| /** |
| * Last |
| * @stable ICU 53 |
| */ |
| LAST, |
| |
| /** |
| * This |
| * @stable ICU 53 |
| */ |
| THIS, |
| |
| /** |
| * Next |
| * @stable ICU 53 |
| */ |
| NEXT, |
| |
| /** |
| * Two after. Not fully supported in every locale |
| * @stable ICU 53 |
| */ |
| NEXT_2, |
| |
| /** |
| * Plain, which means the absence of a qualifier |
| * @stable ICU 53 |
| */ |
| PLAIN; |
| } |
| |
| /** |
| * Returns a RelativeDateTimeFormatter for the default locale. |
| * @stable ICU 53 |
| */ |
| public static RelativeDateTimeFormatter getInstance() { |
| return getInstance(ULocale.getDefault(), null, Style.LONG, DisplayContext.CAPITALIZATION_NONE); |
| } |
| |
| /** |
| * Returns a RelativeDateTimeFormatter for a particular locale. |
| * |
| * @param locale the locale. |
| * @return An instance of RelativeDateTimeFormatter. |
| * @stable ICU 53 |
| */ |
| public static RelativeDateTimeFormatter getInstance(ULocale locale) { |
| return getInstance(locale, null, Style.LONG, DisplayContext.CAPITALIZATION_NONE); |
| } |
| |
| /** |
| * Returns a RelativeDateTimeFormatter for a particular JDK locale. |
| * |
| * @param locale the JDK locale. |
| * @return An instance of RelativeDateTimeFormatter. |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| public static RelativeDateTimeFormatter getInstance(Locale locale) { |
| return getInstance(ULocale.forLocale(locale)); |
| } |
| |
| /** |
| * Returns a RelativeDateTimeFormatter for a particular locale that uses a particular |
| * NumberFormat object. |
| * |
| * @param locale the locale |
| * @param nf the number format object. It is defensively copied to ensure thread-safety |
| * and immutability of this class. |
| * @return An instance of RelativeDateTimeFormatter. |
| * @stable ICU 53 |
| */ |
| public static RelativeDateTimeFormatter getInstance(ULocale locale, NumberFormat nf) { |
| return getInstance(locale, nf, Style.LONG, DisplayContext.CAPITALIZATION_NONE); |
| } |
| |
| /** |
| * Returns a RelativeDateTimeFormatter for a particular locale that uses a particular |
| * NumberFormat object, style, and capitalization context |
| * |
| * @param locale the locale |
| * @param nf the number format object. It is defensively copied to ensure thread-safety |
| * and immutability of this class. May be null. |
| * @param style the style. |
| * @param capitalizationContext the capitalization context. |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| public static RelativeDateTimeFormatter getInstance( |
| ULocale locale, |
| NumberFormat nf, |
| Style style, |
| DisplayContext capitalizationContext) { |
| RelativeDateTimeFormatterData data = cache.get(locale); |
| if (nf == null) { |
| nf = NumberFormat.getInstance(locale); |
| } else { |
| nf = (NumberFormat) nf.clone(); |
| } |
| return new RelativeDateTimeFormatter( |
| data.qualitativeUnitMap, |
| data.quantitativeUnitMap, |
| new MessageFormat(data.dateTimePattern), |
| PluralRules.forLocale(locale), |
| nf, |
| style, |
| capitalizationContext, |
| capitalizationContext == DisplayContext.CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE ? |
| BreakIterator.getSentenceInstance(locale) : null, |
| locale); |
| |
| } |
| |
| /** |
| * Returns a RelativeDateTimeFormatter for a particular JDK locale that uses a particular |
| * NumberFormat object. |
| * |
| * @param locale the JDK locale |
| * @param nf the number format object. It is defensively copied to ensure thread-safety |
| * and immutability of this class. |
| * @return An instance of RelativeDateTimeFormatter. |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| public static RelativeDateTimeFormatter getInstance(Locale locale, NumberFormat nf) { |
| return getInstance(ULocale.forLocale(locale), nf); |
| } |
| |
| /** |
| * Formats a relative date with a quantity such as "in 5 days" or |
| * "3 months ago" |
| * @param quantity The numerical amount e.g 5. This value is formatted |
| * according to this object's {@link NumberFormat} object. |
| * @param direction NEXT means a future relative date; LAST means a past |
| * relative date. |
| * @param unit the unit e.g day? month? year? |
| * @return the formatted string |
| * @throws IllegalArgumentException if direction is something other than |
| * NEXT or LAST. |
| * @stable ICU 53 |
| */ |
| public String format(double quantity, Direction direction, RelativeUnit unit) { |
| if (direction != Direction.LAST && direction != Direction.NEXT) { |
| throw new IllegalArgumentException("direction must be NEXT or LAST"); |
| } |
| String result; |
| // This class is thread-safe, yet numberFormat is not. To ensure thread-safety of this |
| // class we must guarantee that only one thread at a time uses our numberFormat. |
| synchronized (numberFormat) { |
| result = getQuantity( |
| unit, direction == Direction.NEXT).format( |
| quantity, numberFormat, pluralRules); |
| } |
| return adjustForContext(result); |
| } |
| |
| |
| /** |
| * Formats a relative date without a quantity. |
| * @param direction NEXT, LAST, THIS, etc. |
| * @param unit e.g SATURDAY, DAY, MONTH |
| * @return the formatted string. If direction has a value that is documented as not being |
| * fully supported in every locale (for example NEXT_2 or LAST_2) then this function may |
| * return null to signal that no formatted string is available. |
| * @throws IllegalArgumentException if the direction is incompatible with |
| * unit this can occur with NOW which can only take PLAIN. |
| * @stable ICU 53 |
| */ |
| public String format(Direction direction, AbsoluteUnit unit) { |
| if (unit == AbsoluteUnit.NOW && direction != Direction.PLAIN) { |
| throw new IllegalArgumentException("NOW can only accept direction PLAIN."); |
| } |
| String result = this.qualitativeUnitMap.get(style).get(unit).get(direction); |
| return result != null ? adjustForContext(result) : null; |
| } |
| |
| /** |
| * Combines a relative date string and a time string in this object's |
| * locale. This is done with the same date-time separator used for the |
| * default calendar in this locale. |
| * @param relativeDateString the relative date e.g 'yesterday' |
| * @param timeString the time e.g '3:45' |
| * @return the date and time concatenated according to the default |
| * calendar in this locale e.g 'yesterday, 3:45' |
| * @stable ICU 53 |
| */ |
| public String combineDateAndTime(String relativeDateString, String timeString) { |
| return this.combinedDateAndTime.format( |
| new Object[]{timeString, relativeDateString}, new StringBuffer(), null).toString(); |
| } |
| |
| /** |
| * Returns a copy of the NumberFormat this object is using. |
| * @return A copy of the NumberFormat. |
| * @stable ICU 53 |
| */ |
| public NumberFormat getNumberFormat() { |
| // This class is thread-safe, yet numberFormat is not. To ensure thread-safety of this |
| // class we must guarantee that only one thread at a time uses our numberFormat. |
| synchronized (numberFormat) { |
| return (NumberFormat) numberFormat.clone(); |
| } |
| } |
| |
| /** |
| * Return capitalization context. |
| * |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| public DisplayContext getCapitalizationContext() { |
| return capitalizationContext; |
| } |
| |
| /** |
| * Return style |
| * |
| * @draft ICU 54 |
| * @provisional This API might change or be removed in a future release. |
| */ |
| public Style getFormatStyle() { |
| return style; |
| } |
| |
| private String adjustForContext(String originalFormattedString) { |
| if (breakIterator == null || originalFormattedString.length() == 0 |
| || !UCharacter.isLowerCase(UCharacter.codePointAt(originalFormattedString, 0))) { |
| return originalFormattedString; |
| } |
| synchronized (breakIterator) { |
| return UCharacter.toTitleCase( |
| locale, |
| originalFormattedString, |
| breakIterator, |
| UCharacter.TITLECASE_NO_LOWERCASE | UCharacter.TITLECASE_NO_BREAK_ADJUSTMENT); |
| } |
| } |
| |
| private static void addQualitativeUnit( |
| EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnits, |
| AbsoluteUnit unit, |
| String current) { |
| EnumMap<Direction, String> unitStrings = |
| new EnumMap<Direction, String>(Direction.class); |
| unitStrings.put(Direction.PLAIN, current); |
| qualitativeUnits.put(unit, unitStrings); |
| } |
| |
| private static void addQualitativeUnit( |
| EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnits, |
| AbsoluteUnit unit, ICUResourceBundle bundle, String plain) { |
| EnumMap<Direction, String> unitStrings = |
| new EnumMap<Direction, String>(Direction.class); |
| unitStrings.put(Direction.LAST, bundle.getStringWithFallback("-1")); |
| unitStrings.put(Direction.THIS, bundle.getStringWithFallback("0")); |
| unitStrings.put(Direction.NEXT, bundle.getStringWithFallback("1")); |
| addOptionalDirection(unitStrings, Direction.LAST_2, bundle, "-2"); |
| addOptionalDirection(unitStrings, Direction.NEXT_2, bundle, "2"); |
| unitStrings.put(Direction.PLAIN, plain); |
| qualitativeUnits.put(unit, unitStrings); |
| } |
| |
| private static void addOptionalDirection( |
| EnumMap<Direction, String> unitStrings, |
| Direction direction, |
| ICUResourceBundle bundle, |
| String key) { |
| String s = bundle.findStringWithFallback(key); |
| if (s != null) { |
| unitStrings.put(direction, s); |
| } |
| } |
| |
| private RelativeDateTimeFormatter( |
| EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>> qualitativeUnitMap, |
| EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>> quantitativeUnitMap, |
| MessageFormat combinedDateAndTime, |
| PluralRules pluralRules, |
| NumberFormat numberFormat, |
| Style style, |
| DisplayContext capitalizationContext, |
| BreakIterator breakIterator, |
| ULocale locale) { |
| this.qualitativeUnitMap = qualitativeUnitMap; |
| this.quantitativeUnitMap = quantitativeUnitMap; |
| this.combinedDateAndTime = combinedDateAndTime; |
| this.pluralRules = pluralRules; |
| this.numberFormat = numberFormat; |
| this.style = style; |
| if (capitalizationContext.type() != DisplayContext.Type.CAPITALIZATION) { |
| throw new IllegalArgumentException(capitalizationContext.toString()); |
| } |
| this.capitalizationContext = capitalizationContext; |
| this.breakIterator = breakIterator; |
| this.locale = locale; |
| } |
| |
| private QuantityFormatter getQuantity(RelativeUnit unit, boolean isFuture) { |
| QuantityFormatter[] quantities = quantitativeUnitMap.get(style).get(unit); |
| return isFuture ? quantities[1] : quantities[0]; |
| } |
| |
| private final EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>> qualitativeUnitMap; |
| private final EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>> quantitativeUnitMap; |
| private final MessageFormat combinedDateAndTime; |
| private final PluralRules pluralRules; |
| private final NumberFormat numberFormat; |
| private final Style style; |
| private final DisplayContext capitalizationContext; |
| private final BreakIterator breakIterator; |
| private final ULocale locale; |
| |
| private static class RelativeDateTimeFormatterData { |
| public RelativeDateTimeFormatterData( |
| EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>> qualitativeUnitMap, |
| EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>> quantitativeUnitMap, |
| String dateTimePattern) { |
| this.qualitativeUnitMap = qualitativeUnitMap; |
| this.quantitativeUnitMap = quantitativeUnitMap; |
| this.dateTimePattern = dateTimePattern; |
| } |
| |
| public final EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>> qualitativeUnitMap; |
| public final EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>> quantitativeUnitMap; |
| public final String dateTimePattern; // Example: "{1}, {0}" |
| } |
| |
| private static class Cache { |
| private final ICUCache<String, RelativeDateTimeFormatterData> cache = |
| new SimpleCache<String, RelativeDateTimeFormatterData>(); |
| |
| public RelativeDateTimeFormatterData get(ULocale locale) { |
| String key = locale.toString(); |
| RelativeDateTimeFormatterData result = cache.get(key); |
| if (result == null) { |
| result = new Loader(locale).load(); |
| cache.put(key, result); |
| } |
| return result; |
| } |
| } |
| |
| private static class Loader { |
| private final ULocale ulocale; |
| |
| public Loader(ULocale ulocale) { |
| this.ulocale = ulocale; |
| } |
| |
| public RelativeDateTimeFormatterData load() { |
| EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>> qualitativeUnitMap = |
| new EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>>(Style.class); |
| |
| EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>> quantitativeUnitMap = |
| new EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>>(Style.class); |
| |
| for (Style style : Style.values()) { |
| qualitativeUnitMap.put(style, new EnumMap<AbsoluteUnit, EnumMap<Direction, String>>(AbsoluteUnit.class)); |
| quantitativeUnitMap.put(style, new EnumMap<RelativeUnit, QuantityFormatter[]>(RelativeUnit.class)); |
| } |
| |
| ICUResourceBundle r = (ICUResourceBundle)UResourceBundle. |
| getBundleInstance(ICUResourceBundle.ICU_BASE_NAME, ulocale); |
| addTimeUnits( |
| r, |
| "fields/day", "fields/day-short", "fields/day-narrow", |
| RelativeUnit.DAYS, |
| AbsoluteUnit.DAY, |
| quantitativeUnitMap, |
| qualitativeUnitMap); |
| addTimeUnits( |
| r, |
| "fields/week", "fields/week-short", "fields/week-narrow", |
| RelativeUnit.WEEKS, |
| AbsoluteUnit.WEEK, |
| quantitativeUnitMap, |
| qualitativeUnitMap); |
| addTimeUnits( |
| r, |
| "fields/month", "fields/month-short", "fields/month-narrow", |
| RelativeUnit.MONTHS, |
| AbsoluteUnit.MONTH, |
| quantitativeUnitMap, |
| qualitativeUnitMap); |
| addTimeUnits( |
| r, |
| "fields/year", "fields/year-short", "fields/year-narrow", |
| RelativeUnit.YEARS, |
| AbsoluteUnit.YEAR, |
| quantitativeUnitMap, |
| qualitativeUnitMap); |
| initRelativeUnits( |
| r, |
| "fields/second", "fields/second-short", "fields/second-narrow", |
| RelativeUnit.SECONDS, |
| quantitativeUnitMap); |
| initRelativeUnits( |
| r, |
| "fields/minute", "fields/minute-short", "fields/minute-narrow", |
| RelativeUnit.MINUTES, |
| quantitativeUnitMap); |
| initRelativeUnits( |
| r, |
| "fields/hour", "fields/hour-short", "fields/hour-narrow", |
| RelativeUnit.HOURS, |
| quantitativeUnitMap); |
| |
| addQualitativeUnit( |
| qualitativeUnitMap.get(Style.LONG), |
| AbsoluteUnit.NOW, |
| r.getStringWithFallback("fields/second/relative/0")); |
| addQualitativeUnit( |
| qualitativeUnitMap.get(Style.SHORT), |
| AbsoluteUnit.NOW, |
| r.getStringWithFallback("fields/second-short/relative/0")); |
| addQualitativeUnit( |
| qualitativeUnitMap.get(Style.NARROW), |
| AbsoluteUnit.NOW, |
| r.getStringWithFallback("fields/second-narrow/relative/0")); |
| |
| EnumMap<Style, EnumMap<AbsoluteUnit, String>> dayOfWeekMap = |
| new EnumMap<Style, EnumMap<AbsoluteUnit, String>>(Style.class); |
| dayOfWeekMap.put(Style.LONG, readDaysOfWeek( |
| r.getWithFallback("calendar/gregorian/dayNames/stand-alone/wide"))); |
| dayOfWeekMap.put(Style.SHORT, readDaysOfWeek( |
| r.getWithFallback("calendar/gregorian/dayNames/stand-alone/short"))); |
| dayOfWeekMap.put(Style.NARROW, readDaysOfWeek( |
| r.getWithFallback("calendar/gregorian/dayNames/stand-alone/narrow"))); |
| |
| addWeekDays( |
| r, |
| "fields/mon/relative", |
| "fields/mon-short/relative", |
| "fields/mon-narrow/relative", |
| dayOfWeekMap, |
| AbsoluteUnit.MONDAY, |
| qualitativeUnitMap); |
| addWeekDays( |
| r, |
| "fields/tue/relative", |
| "fields/tue-short/relative", |
| "fields/tue-narrow/relative", |
| dayOfWeekMap, |
| AbsoluteUnit.TUESDAY, |
| qualitativeUnitMap); |
| addWeekDays( |
| r, |
| "fields/wed/relative", |
| "fields/wed-short/relative", |
| "fields/wed-narrow/relative", |
| dayOfWeekMap, |
| AbsoluteUnit.WEDNESDAY, |
| qualitativeUnitMap); |
| addWeekDays( |
| r, |
| "fields/thu/relative", |
| "fields/thu-short/relative", |
| "fields/thu-narrow/relative", |
| dayOfWeekMap, |
| AbsoluteUnit.THURSDAY, |
| qualitativeUnitMap); |
| addWeekDays( |
| r, |
| "fields/fri/relative", |
| "fields/fri-short/relative", |
| "fields/fri-narrow/relative", |
| dayOfWeekMap, |
| AbsoluteUnit.FRIDAY, |
| qualitativeUnitMap); |
| addWeekDays( |
| r, |
| "fields/sat/relative", |
| "fields/sat-short/relative", |
| "fields/sat-narrow/relative", |
| dayOfWeekMap, |
| AbsoluteUnit.SATURDAY, |
| qualitativeUnitMap); |
| addWeekDays( |
| r, |
| "fields/sun/relative", |
| "fields/sun-short/relative", |
| "fields/sun-narrow/relative", |
| dayOfWeekMap, |
| AbsoluteUnit.SUNDAY, |
| qualitativeUnitMap); |
| CalendarData calData = new CalendarData( |
| ulocale, r.getStringWithFallback("calendar/default")); |
| return new RelativeDateTimeFormatterData( |
| qualitativeUnitMap, quantitativeUnitMap, calData.getDateTimePattern()); |
| } |
| |
| private void addTimeUnits( |
| ICUResourceBundle r, |
| String path, String pathShort, String pathNarrow, |
| RelativeUnit relativeUnit, |
| AbsoluteUnit absoluteUnit, |
| EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>> quantitativeUnitMap, |
| EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>> qualitativeUnitMap) { |
| addTimeUnit( |
| r.getWithFallback(path), |
| relativeUnit, |
| absoluteUnit, |
| quantitativeUnitMap.get(Style.LONG), |
| qualitativeUnitMap.get(Style.LONG)); |
| addTimeUnit( |
| r.getWithFallback(pathShort), |
| relativeUnit, |
| absoluteUnit, |
| quantitativeUnitMap.get(Style.SHORT), |
| qualitativeUnitMap.get(Style.SHORT)); |
| addTimeUnit( |
| r.getWithFallback(pathNarrow), |
| relativeUnit, |
| absoluteUnit, |
| quantitativeUnitMap.get(Style.NARROW), |
| qualitativeUnitMap.get(Style.NARROW)); |
| |
| } |
| |
| private void addTimeUnit( |
| ICUResourceBundle timeUnitBundle, |
| RelativeUnit relativeUnit, |
| AbsoluteUnit absoluteUnit, |
| EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap, |
| EnumMap<AbsoluteUnit, EnumMap<Direction, String>> qualitativeUnitMap) { |
| addTimeUnit(timeUnitBundle, relativeUnit, quantitativeUnitMap); |
| String unitName = timeUnitBundle.getStringWithFallback("dn"); |
| // TODO(Travis Keep): This is a hack to get around CLDR bug 6818. |
| if (ulocale.getLanguage().equals("en")) { |
| unitName = unitName.toLowerCase(); |
| } |
| timeUnitBundle = timeUnitBundle.getWithFallback("relative"); |
| addQualitativeUnit( |
| qualitativeUnitMap, |
| absoluteUnit, |
| timeUnitBundle, |
| unitName); |
| } |
| |
| private void initRelativeUnits( |
| ICUResourceBundle r, |
| String path, |
| String pathShort, |
| String pathNarrow, |
| RelativeUnit relativeUnit, |
| EnumMap<Style, EnumMap<RelativeUnit, QuantityFormatter[]>> quantitativeUnitMap) { |
| addTimeUnit( |
| r.getWithFallback(path), |
| relativeUnit, |
| quantitativeUnitMap.get(Style.LONG)); |
| addTimeUnit( |
| r.getWithFallback(pathShort), |
| relativeUnit, |
| quantitativeUnitMap.get(Style.SHORT)); |
| addTimeUnit( |
| r.getWithFallback(pathNarrow), |
| relativeUnit, |
| quantitativeUnitMap.get(Style.NARROW)); |
| } |
| |
| private static void addTimeUnit( |
| ICUResourceBundle timeUnitBundle, |
| RelativeUnit relativeUnit, |
| EnumMap<RelativeUnit, QuantityFormatter[]> quantitativeUnitMap) { |
| QuantityFormatter.Builder future = new QuantityFormatter.Builder(); |
| QuantityFormatter.Builder past = new QuantityFormatter.Builder(); |
| timeUnitBundle = timeUnitBundle.getWithFallback("relativeTime"); |
| addTimeUnit( |
| timeUnitBundle.getWithFallback("future"), |
| future); |
| addTimeUnit( |
| timeUnitBundle.getWithFallback("past"), |
| past); |
| quantitativeUnitMap.put( |
| relativeUnit, new QuantityFormatter[] { past.build(), future.build() }); |
| } |
| |
| private static void addTimeUnit( |
| ICUResourceBundle pastOrFuture, QuantityFormatter.Builder builder) { |
| int size = pastOrFuture.getSize(); |
| for (int i = 0; i < size; i++) { |
| UResourceBundle r = pastOrFuture.get(i); |
| builder.add(r.getKey(), r.getString()); |
| } |
| } |
| |
| private void addWeekDays( |
| ICUResourceBundle r, |
| String path, |
| String pathShort, |
| String pathNarrow, |
| EnumMap<Style, EnumMap<AbsoluteUnit, String>> dayOfWeekMap, |
| AbsoluteUnit weekDay, |
| EnumMap<Style, EnumMap<AbsoluteUnit, EnumMap<Direction, String>>> qualitativeUnitMap) { |
| addQualitativeUnit( |
| qualitativeUnitMap.get(Style.LONG), |
| weekDay, |
| r.findWithFallback(path), |
| dayOfWeekMap.get(Style.LONG).get(weekDay)); |
| addQualitativeUnit( |
| qualitativeUnitMap.get(Style.SHORT), |
| weekDay, |
| r.findWithFallback(pathShort), |
| dayOfWeekMap.get(Style.SHORT).get(weekDay)); |
| addQualitativeUnit( |
| qualitativeUnitMap.get(Style.NARROW), |
| weekDay, |
| r.findWithFallback(pathNarrow), |
| dayOfWeekMap.get(Style.NARROW).get(weekDay)); |
| |
| } |
| |
| private static EnumMap<AbsoluteUnit, String> readDaysOfWeek(ICUResourceBundle daysOfWeekBundle) { |
| EnumMap<AbsoluteUnit, String> dayOfWeekMap = new EnumMap<AbsoluteUnit, String>(AbsoluteUnit.class); |
| if (daysOfWeekBundle.getSize() != 7) { |
| throw new IllegalStateException(String.format("Expect 7 days in a week, got %d", daysOfWeekBundle.getSize())); |
| } |
| // Sunday always comes first in CLDR data. |
| int idx = 0; |
| dayOfWeekMap.put(AbsoluteUnit.SUNDAY, daysOfWeekBundle.getString(idx++)); |
| dayOfWeekMap.put(AbsoluteUnit.MONDAY, daysOfWeekBundle.getString(idx++)); |
| dayOfWeekMap.put(AbsoluteUnit.TUESDAY, daysOfWeekBundle.getString(idx++)); |
| dayOfWeekMap.put(AbsoluteUnit.WEDNESDAY, daysOfWeekBundle.getString(idx++)); |
| dayOfWeekMap.put(AbsoluteUnit.THURSDAY, daysOfWeekBundle.getString(idx++)); |
| dayOfWeekMap.put(AbsoluteUnit.FRIDAY, daysOfWeekBundle.getString(idx++)); |
| dayOfWeekMap.put(AbsoluteUnit.SATURDAY, daysOfWeekBundle.getString(idx++)); |
| return dayOfWeekMap; |
| } |
| } |
| |
| private static final Cache cache = new Cache(); |
| } |
