Пример #1
0
 public CldrDateTimeFormat(CldrCalendarInfo info, DateTimePartStyles style, string pattern, List <string> patternId)
 {
     Guard.ArgumentNotNull(info, "info");
     Guard.ArgumentNotNull(pattern, "pattern");
     Guard.ArgumentNotNull(patternId, "patternId");
     this.Styles       = style;
     this.CalendarInfo = info;
     this.Pattern      = pattern;
     this.PatternId    = patternId.AsReadOnly();
 }
Пример #2
0
        public static EcmaValue ResolvedOptions([This] EcmaValue thisValue)
        {
            DateTimeFormat     formatter          = thisValue.GetUnderlyingObject <DateTimeFormat>();
            DateTimePartStyles dateTimePartStyles = formatter.DateTimePartStyles;
            EcmaObject         obj = new EcmaObject();

            obj.CreateDataPropertyOrThrow(PropertyKey.Locale, formatter.Locale);
            obj.CreateDataPropertyOrThrow(PropertyKey.Calendar, formatter.Calendar);
            obj.CreateDataPropertyOrThrow(PropertyKey.TimeZone, formatter.TimeZone);
            obj.CreateDataPropertyOrThrow(PropertyKey.Hour12, formatter.Hour12);
            obj.CreateDataPropertyOrThrow(PropertyKey.HourCycle, IntlProviderOptions.ToStringValue(formatter.HourCycle));
            obj.CreateDataPropertyOrThrow(PropertyKey.FormatMatcher, IntlProviderOptions.ToStringValue(formatter.FormatMatcher));
            if (dateTimePartStyles.Weekday != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Weekday, IntlProviderOptions.ToStringValue(dateTimePartStyles.Weekday));
            }
            if (dateTimePartStyles.Era != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Era, IntlProviderOptions.ToStringValue(dateTimePartStyles.Era));
            }
            if (dateTimePartStyles.Year != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Year, IntlProviderOptions.ToStringValue(dateTimePartStyles.Year));
            }
            if (dateTimePartStyles.Month != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Month, IntlProviderOptions.ToStringValue(dateTimePartStyles.Month));
            }
            if (dateTimePartStyles.Day != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Day, IntlProviderOptions.ToStringValue(dateTimePartStyles.Day));
            }
            if (dateTimePartStyles.Hour != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Hour, IntlProviderOptions.ToStringValue(dateTimePartStyles.Hour));
            }
            if (dateTimePartStyles.Minute != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Minute, IntlProviderOptions.ToStringValue(dateTimePartStyles.Minute));
            }
            if (dateTimePartStyles.Second != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.Second, IntlProviderOptions.ToStringValue(dateTimePartStyles.Second));
            }
            if (dateTimePartStyles.TimeZoneName != default)
            {
                obj.CreateDataPropertyOrThrow(PropertyKey.TimeZoneName, IntlProviderOptions.ToStringValue(dateTimePartStyles.TimeZoneName));
            }
            return(obj);
        }
Пример #3
0
        public ReadOnlyCollection <CldrDateTimeFormat> GetAvailableDateTimeFormats()
        {
            if (this.dateTimeFormats == null)
            {
                ReadOnlyCollection <CldrDateTimeFormat> datePatterns    = GetAvailableDateFormats();
                ReadOnlyCollection <CldrDateTimeFormat> timePatterns    = Resolve(locale, "gregory").GetAvailableTimeFormats();
                Dictionary <string, string>             combinePatterns = Resolve(locale, "generic").GetCombinePatterns();
                List <CldrDateTimeFormat> dateTimeFormats = new List <CldrDateTimeFormat>();
                foreach (CldrDateTimeFormat dateFormat in datePatterns)
                {
                    string combinePattern;
                    if (dateFormat.Styles.Weekday == WeekdayStyle.Long)
                    {
                        combinePattern = combinePatterns["full"];
                    }
                    else
                    {
                        switch (dateFormat.Styles.Month)
                        {
                        case MonthStyle.Long:
                            combinePattern = combinePatterns["full"];
                            break;

                        case MonthStyle.Short:
                            combinePattern = combinePatterns["long"];
                            break;

                        case MonthStyle.Narrow:
                            combinePattern = combinePatterns["medium"];
                            break;

                        default:
                            combinePattern = combinePatterns["short"];
                            break;
                        }
                    }
                    foreach (CldrDateTimeFormat timeFormat in timePatterns)
                    {
                        List <string> keys = new List <string>(dateFormat.PatternId);
                        keys.AddRange(timeFormat.PatternId);
                        DateTimePartStyles combinedStyle  = new DateTimePartStyles(dateFormat.Styles, timeFormat.Styles);
                        CldrDateTimeFormat combinedFormat = new CldrDateTimeFormat(this, combinedStyle, String.Format(combinePattern, timeFormat.Pattern, dateFormat.Pattern), keys);
                        dateTimeFormats.Add(combinedFormat);
                    }
                }
                this.dateTimeFormats = dateTimeFormats.AsReadOnly();
            }
            return(this.dateTimeFormats);
        }
Пример #4
0
        private static string ParseDateTimeFormat(string format, out DateTimePartStyles style)
        {
            WeekdayStyle             weekday      = default;
            EraStyle                 era          = default;
            MonthStyle               month        = default;
            NumericDateTimePartStyle year         = default;
            NumericDateTimePartStyle day          = default;
            NumericDateTimePartStyle hour         = default;
            NumericDateTimePartStyle minute       = default;
            NumericDateTimePartStyle second       = default;
            TimeZoneNameStyle        timeZoneName = default;
            bool   isHour12 = false;
            string pattern  = Regex.Replace(format, "('([^']*)'|(?<d>[yMLdGEcabBhHkKmszv])(\\k<d>)*)", m => {
                switch (m.Value[0])
                {
                case 'y':
                    year = m.Length == 2 ? NumericDateTimePartStyle.TwoDigit : NumericDateTimePartStyle.Numeric;
                    return("{year}");

                case 'M':
                case 'L':
                    switch (m.Length)
                    {
                    case 1:
                        month = MonthStyle.Numeric;
                        break;

                    case 2:
                        month = MonthStyle.TwoDigit;
                        break;

                    case 3:
                        month = MonthStyle.Short;
                        break;

                    case 4:
                        month = MonthStyle.Long;
                        break;

                    case 5:
                        month = MonthStyle.Narrow;
                        break;
                    }
                    return("{month}");

                case 'd':
                    day = m.Length == 2 ? NumericDateTimePartStyle.TwoDigit : NumericDateTimePartStyle.Numeric;
                    return("{day}");

                case 'E':
                case 'c':
                    weekday = m.Length == 2 ? WeekdayStyle.Short : m.Length == 3 ? WeekdayStyle.Long : WeekdayStyle.Narrow;
                    return("{weekday}");

                case 'G':
                    era = EraStyle.Long;
                    return("{era}");

                case 'a':
                case 'b':
                case 'B':
                    isHour12 = true;
                    return("{ampm}");

                case 'h':
                case 'H':
                case 'k':
                case 'K':
                    hour = m.Length == 2 ? NumericDateTimePartStyle.TwoDigit : NumericDateTimePartStyle.Numeric;
                    return("{hour}");

                case 'm':
                    minute = m.Length == 2 ? NumericDateTimePartStyle.TwoDigit : NumericDateTimePartStyle.Numeric;
                    return("{minute}");

                case 's':
                    second = m.Length == 2 ? NumericDateTimePartStyle.TwoDigit : NumericDateTimePartStyle.Numeric;
                    return("{second}");

                case 'z':
                case 'v':
                    timeZoneName = m.Length == 1 ? TimeZoneNameStyle.Short : TimeZoneNameStyle.Long;
                    return("{timeZoneName}");
                }
                return(m.Length == 2 ? "'" : m.Groups[1].Value);
            });

            style = new DateTimePartStyles(weekday, era, year, month, day, hour, minute, second, timeZoneName, isHour12);
            return(pattern);
        }