Exemple #1
0
        public void Init()
        {
            var lang = "en-US";

            Thread.CurrentThread.CurrentCulture   = CultureInfo.CreateSpecificCulture(lang);
            Thread.CurrentThread.CurrentUICulture = CultureInfo.CreateSpecificCulture(lang);

            _infoForWeek             = (TimeAgoFormatInfo)TimeAgoFormatInfo.CultureInfo.Clone();
            _infoForWeek.UseTimeAgo |= UseTimeAgo.UseWeek;

            _infoForMonth             = (TimeAgoFormatInfo)_infoForWeek.Clone();
            _infoForMonth.UseTimeAgo |= UseTimeAgo.UseMonth;

            _infoForYear             = (TimeAgoFormatInfo)_infoForMonth.Clone();
            _infoForYear.UseTimeAgo |= UseTimeAgo.UseYear;

            _infoForDecade             = (TimeAgoFormatInfo)_infoForYear.Clone();
            _infoForDecade.UseTimeAgo |= UseTimeAgo.UseDecade;

            _infoForCentury             = (TimeAgoFormatInfo)_infoForDecade.Clone();
            _infoForCentury.UseTimeAgo |= UseTimeAgo.UseCentury;
        }
Exemple #2
0
        internal static string ToTimeAgo(this TimeSpan value, IFormatProvider provider, TimeAgoFormatInfo formatter, ITimeAgoFormatDelegate formatterDelegate)
        {
            var ticks = value.Ticks;

            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseNow))
            {
                // Now
                if (ticks <= formatter.SwitchUntilNowInSeconds * TimeSpan.TicksPerSecond)
                {
                    return(formatterDelegate.NowPattern);
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseSecond))
            {
                // 1s
                if (ticks < 2 * TimeSpan.TicksPerSecond)
                {
                    return(formatterDelegate.SecondPattern);
                }
                // Xs
                if (ticks < TimeSpan.TicksPerMinute)
                {
                    return(string.Format(formatterDelegate.SecondsPattern, value.Seconds));
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseMinute))
            {
                // 1m
                if (ticks < TimeSpan.TicksPerMinute + TimeSpan.TicksPerSecond)
                {
                    return(formatterDelegate.MinutePattern);
                }
                if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseSecond | UseTimeAgo.UseComplex))
                {
                    // 1m Xs
                    if (ticks < 2 * TimeSpan.TicksPerMinute)
                    {
                        return(string.Format(formatterDelegate.MinuteSecondsPattern, value.Seconds));
                    }
                    // Xm / Xm 1s / Xm Ys
                    if (ticks < TimeSpan.TicksPerHour)
                    {
                        if (value.Seconds == 0)
                        {
                            return(string.Format(formatterDelegate.MinutesPattern, value.Minutes));
                        }
                        if (value.Seconds == 1)
                        {
                            return(string.Format(formatterDelegate.MinutesSecondPattern, value.Minutes));
                        }

                        return(string.Format(formatterDelegate.MinutesSecondsPattern, value.Minutes, value.Seconds));
                    }
                }
                else
                {
                    // Xm
                    if (ticks < TimeSpan.TicksPerHour)
                    {
                        return(string.Format(formatterDelegate.MinutesPattern, value.Minutes));
                    }
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseHour))
            {
                // 1h
                if (ticks < TimeSpan.TicksPerHour + TimeSpan.TicksPerMinute)
                {
                    return(formatterDelegate.HourPattern);
                }
                if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseMinute | UseTimeAgo.UseComplex))
                {
                    // 1h Xm
                    if (ticks < 2 * TimeSpan.TicksPerHour)
                    {
                        return(string.Format(formatterDelegate.HourMinutesPattern, value.Minutes));
                    }
                    // Xh / Xh 1m / Xh Ym
                    if (ticks < TimeSpan.TicksPerDay)
                    {
                        if (value.Minutes == 0)
                        {
                            return(string.Format(formatterDelegate.HoursPattern, value.Hours));
                        }
                        if (value.Minutes == 1)
                        {
                            return(string.Format(formatterDelegate.HoursMinutePattern, value.Hours));
                        }

                        return(string.Format(formatterDelegate.HoursMinutesPattern, value.Hours, value.Minutes));
                    }
                    if (!formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseDay | UseTimeAgo.UseWeek | UseTimeAgo.UseMonth | UseTimeAgo.UseYear | UseTimeAgo.UseDecade | UseTimeAgo.UseCentury))
                    {
                        if (value.Minutes == 0)
                        {
                            return(string.Format(formatterDelegate.HoursPattern, (int)value.TotalHours));
                        }
                        if (value.Minutes == 1)
                        {
                            return(string.Format(formatterDelegate.HoursMinutePattern, (int)value.TotalHours));
                        }

                        return(string.Format(formatterDelegate.HoursMinutesPattern, (int)value.TotalHours, value.Minutes));
                    }
                }
                else
                {
                    // Xh
                    if (ticks < TimeSpan.TicksPerDay)
                    {
                        return(string.Format(formatterDelegate.HoursPattern, value.Hours));
                    }
                    if (!formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseDay | UseTimeAgo.UseWeek | UseTimeAgo.UseMonth | UseTimeAgo.UseYear | UseTimeAgo.UseDecade | UseTimeAgo.UseCentury))
                    {
                        return(string.Format(formatterDelegate.HoursPattern, (int)value.TotalHours));
                    }
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseDay))
            {
                // 1d
                if (ticks < TimeSpan.TicksPerDay + TimeSpan.TicksPerHour)
                {
                    return(formatterDelegate.DayPattern);
                }
                if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseHour | UseTimeAgo.UseComplex))
                {
                    // 1d Xh
                    if (ticks < 2 * TimeSpan.TicksPerDay)
                    {
                        return(string.Format(formatterDelegate.DayHoursPattern, value.Hours));
                    }
                    // Xd / Xd 1h / Xd Yh
                    if (ticks < TimeSpan.TicksPerMinute ||
                        !formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseWeek | UseTimeAgo.UseMonth | UseTimeAgo.UseYear | UseTimeAgo.UseDecade | UseTimeAgo.UseCentury))
                    {
                        if (value.Hours == 0)
                        {
                            return(string.Format(formatterDelegate.DaysPattern, value.Days));
                        }
                        if (value.Hours == 1)
                        {
                            return(string.Format(formatterDelegate.DaysHourPattern, value.Days));
                        }

                        return(string.Format(formatterDelegate.DaysHoursPattern, value.Days, value.Hours));
                    }
                }
                else
                {
                    // Xd
                    if (ticks < TicksPerWeek ||
                        !formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseWeek | UseTimeAgo.UseMonth | UseTimeAgo.UseYear | UseTimeAgo.UseDecade | UseTimeAgo.UseCentury))
                    {
                        return(string.Format(formatterDelegate.DaysPattern, value.Days));
                    }
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseWeek))
            {
                // 1w
                if (ticks < 2 * TicksPerWeek)
                {
                    return(formatterDelegate.WeekPattern);
                }
                // Xw
                if (ticks < TicksPerMonth ||
                    !formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseMonth | UseTimeAgo.UseYear | UseTimeAgo.UseDecade | UseTimeAgo.UseCentury))
                {
                    return(string.Format(formatterDelegate.WeeksPattern, value.Days / DaysPerWeek));
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseMonth))
            {
                // 1 month
                if (ticks < 2 * TicksPerMonth)
                {
                    return(formatterDelegate.MonthPattern);
                }
                // X months
                if (ticks < TicksPerYear ||
                    !formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseYear | UseTimeAgo.UseDecade | UseTimeAgo.UseCentury))
                {
                    return(string.Format(formatterDelegate.MonthsPattern, value.Days / DaysPerMonth));
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseYear))
            {
                // 1y
                if (ticks < 2 * TicksPerYear)
                {
                    return(formatterDelegate.YearPattern);
                }
                // Xy
                if (ticks < TicksPerDecade ||
                    !formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseDecade | UseTimeAgo.UseCentury))
                {
                    return(string.Format(formatterDelegate.YearsPattern, value.Days / DaysPerYear));
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseDecade))
            {
                // 1 decade
                if (ticks < 2 * TicksPerDecade)
                {
                    return(formatterDelegate.DecadePattern);
                }
                // X decades
                if (ticks < TicksPerCentury ||
                    !formatter.UseTimeAgo.HasAnyFlag(UseTimeAgo.UseCentury))
                {
                    return(string.Format(formatterDelegate.DecadesPattern, value.Days / DaysPerDecade));
                }
            }
            if (formatter.UseTimeAgo.HasFlag(UseTimeAgo.UseCentury))
            {
                // 1 centry
                if (ticks < 2 * TicksPerCentury)
                {
                    return(formatterDelegate.CenturyPattern);
                }
                // X centurys
                return(string.Format(formatterDelegate.CenturysPattern, value.Days / DaysPerCentury));
            }
            throw new InvalidOperationException();
        }
Exemple #3
0
 public MediumTimeAgoFormatDelegate(TimeAgoFormatInfo info) => Info = info;
Exemple #4
0
 public LongTimeAgoFormatDelegate(TimeAgoFormatInfo info) => Info = info;
Exemple #5
0
 public ShortTimeAgoFormatDelegate(TimeAgoFormatInfo info) => Info = info;