Exemple #1
0
        private void DetermineWhen(ref LexerToken tok, ref DateSpecifier specifier)
        {
            Date today = TimesCommon.Current.CurrentDate;

            specifier = specifier ?? new DateSpecifier();

            switch (tok.Kind)
            {
            case LexerTokenKindEnum.TOK_DATE:
                specifier = tok.Value.GetValue <DateSpecifier>();
                break;

            case LexerTokenKindEnum.TOK_INT:
            {
                int amount = tok.Value.GetValue <int>();
                int adjust = 0;

                tok = Lexer.PeekToken();
                LexerTokenKindEnum kind = tok.Kind;
                switch (kind)
                {
                case LexerTokenKindEnum.TOK_YEAR:
                case LexerTokenKindEnum.TOK_YEARS:
                case LexerTokenKindEnum.TOK_QUARTER:
                case LexerTokenKindEnum.TOK_QUARTERS:
                case LexerTokenKindEnum.TOK_MONTH:
                case LexerTokenKindEnum.TOK_MONTHS:
                case LexerTokenKindEnum.TOK_WEEK:
                case LexerTokenKindEnum.TOK_WEEKS:
                case LexerTokenKindEnum.TOK_DAY:
                case LexerTokenKindEnum.TOK_DAYS:
                    Lexer.NextToken();
                    tok = Lexer.NextToken();
                    switch (tok.Kind)
                    {
                    case LexerTokenKindEnum.TOK_AGO:
                        adjust = -1;
                        break;

                    case LexerTokenKindEnum.TOK_HENCE:
                        adjust = 1;
                        break;

                    default:
                        tok.Unexpected();
                        break;
                    }
                    break;

                default:
                    break;
                }

                Date when = today;

                switch (kind)
                {
                case LexerTokenKindEnum.TOK_YEAR:
                case LexerTokenKindEnum.TOK_YEARS:
                    when = when.AddYears(amount * adjust);
                    break;

                case LexerTokenKindEnum.TOK_QUARTER:
                case LexerTokenKindEnum.TOK_QUARTERS:
                    when = when.AddMonths(amount * 3 * adjust);
                    break;

                case LexerTokenKindEnum.TOK_MONTH:
                case LexerTokenKindEnum.TOK_MONTHS:
                    when = when.AddMonths(amount * adjust);
                    break;

                case LexerTokenKindEnum.TOK_WEEK:
                case LexerTokenKindEnum.TOK_WEEKS:
                    when = when.AddDays(amount * 7 * adjust);
                    break;

                case LexerTokenKindEnum.TOK_DAY:
                case LexerTokenKindEnum.TOK_DAYS:
                    when = when.AddDays(amount * adjust);
                    break;

                default:
                    if (amount > 31)
                    {
                        specifier.Year = amount;
                    }
                    else
                    {
                        specifier.Day = amount;
                    }
                    break;
                }

                if (adjust != 0)
                {
                    specifier = new DateSpecifier(when);
                }
                break;
            }

            case LexerTokenKindEnum.TOK_THIS:
            case LexerTokenKindEnum.TOK_NEXT:
            case LexerTokenKindEnum.TOK_LAST:
            {
                int adjust = 0;
                if (tok.Kind == LexerTokenKindEnum.TOK_NEXT)
                {
                    adjust = 1;
                }
                else if (tok.Kind == LexerTokenKindEnum.TOK_LAST)
                {
                    adjust = -1;
                }

                tok = Lexer.NextToken();
                switch (tok.Kind)
                {
                case LexerTokenKindEnum.TOK_A_MONTH:
                {
                    Date temp = new Date(today.Year, tok.Value.GetValue <int>(), 1);
                    temp      = temp.AddYears(adjust);
                    specifier = new DateSpecifier(temp.Year, (MonthEnum)temp.Month);
                    break;
                }

                case LexerTokenKindEnum.TOK_A_WDAY:
                {
                    Date temp = DateDuration.FindNearest(today, SkipQuantumEnum.WEEKS);
                    while (temp.DayOfWeek != tok.Value.GetValue <DayOfWeek>())
                    {
                        temp = temp.AddDays(1);
                    }
                    temp      = temp.AddDays(7 * adjust);
                    specifier = new DateSpecifier(temp);
                    break;
                }

                case LexerTokenKindEnum.TOK_YEAR:
                {
                    Date temp = today;
                    temp      = temp.AddYears(adjust);
                    specifier = new DateSpecifier(temp.Year);
                    break;
                }

                case LexerTokenKindEnum.TOK_QUARTER:
                {
                    Date baseDate = DateDuration.FindNearest(today, SkipQuantumEnum.QUARTERS);
                    Date temp     = default(Date);
                    if (adjust < 0)
                    {
                        temp = baseDate.AddMonths(3 * adjust);
                    }
                    else if (adjust == 0)
                    {
                        temp = baseDate.AddMonths(3);
                    }
                    else if (adjust > 0)
                    {
                        baseDate = baseDate.AddMonths(3 * adjust);
                        temp     = baseDate.AddMonths(3 * adjust);
                    }
                    specifier = new DateSpecifier(adjust < 0 ? temp : baseDate);
                    break;
                }

                case LexerTokenKindEnum.TOK_WEEK:
                {
                    Date baseDate = DateDuration.FindNearest(today, SkipQuantumEnum.WEEKS);
                    Date temp     = default(Date);
                    if (adjust < 0)
                    {
                        temp = baseDate.AddDays(7 * adjust);
                    }
                    else if (adjust == 0)
                    {
                        temp = baseDate.AddDays(7);
                    }
                    else if (adjust > 0)
                    {
                        baseDate = baseDate.AddDays(7 * adjust);
                        temp     = baseDate.AddDays(7 * adjust);
                    }
                    specifier = new DateSpecifier(adjust < 0 ? temp : baseDate);
                    break;
                }

                case LexerTokenKindEnum.TOK_DAY:
                {
                    Date temp = today;
                    temp      = temp.AddDays(adjust);
                    specifier = new DateSpecifier(temp);
                    break;
                }

                case LexerTokenKindEnum.TOK_MONTH:
                default:
                {
                    Date temp = today;
                    temp      = temp.AddMonths(adjust);
                    specifier = new DateSpecifier(temp.Year, (MonthEnum)temp.Month);
                    break;
                }
                }
                break;
            }

            case LexerTokenKindEnum.TOK_A_MONTH:
                specifier.Month = tok.Value.GetValue <MonthEnum>();
                tok             = Lexer.PeekToken();
                switch (tok.Kind)
                {
                case LexerTokenKindEnum.TOK_INT:
                    specifier.Year = tok.Value.GetValue <int>();
                    break;

                case LexerTokenKindEnum.END_REACHED:
                    break;

                default:
                    break;
                }
                break;

            case LexerTokenKindEnum.TOK_A_WDAY:
                specifier.WDay = tok.Value.GetValue <DayOfWeek>();
                break;

            case LexerTokenKindEnum.TOK_TODAY:
                specifier = new DateSpecifier(today);
                break;

            case LexerTokenKindEnum.TOK_TOMORROW:
                specifier = new DateSpecifier(today.AddDays(1));
                break;

            case LexerTokenKindEnum.TOK_YESTERDAY:
                specifier = new DateSpecifier(today.AddDays(-1));
                break;

            default:
                tok.Unexpected();
                break;
            }
        }
Exemple #2
0
        public void Stabilize(Date?date = null)
        {
            if (date.HasValue)
            {
                Logger.Current.Debug("times.interval", () => String.Format("stabilize: with date = {0}", date));
            }

            if (date.HasValue & !Aligned)
            {
                Logger.Current.Debug("times.interval", () => "stabilize: date passed, but not aligned");
                if (Duration != null)
                {
                    Logger.Current.Debug("times.interval", () => String.Format("stabilize: aligning with a duration: {0}", Duration));

                    // The interval object has not been seeded with a start date yet, so
                    // find the nearest period before on on date which fits, if possible.
                    //
                    // Find an efficient starting point for the upcoming while loop.  We
                    // want a date early enough that the range will be correct, but late
                    // enough that we don't spend hundreds of thousands of loops skipping
                    // through time.
                    Date?initialStart  = Start ?? Begin;
                    Date?initialFinish = Finish ?? End;

                    if (initialStart.HasValue)
                    {
                        Logger.Current.Debug("times.interval", () => String.Format("stabilize: initial_start  = {0}", initialStart));
                    }
                    if (initialFinish.HasValue)
                    {
                        Logger.Current.Debug("times.interval", () => String.Format("stabilize: initial_finish = {0}", initialFinish));
                    }

                    Date when = Start ?? date.Value;

                    switch (Duration.Quantum)
                    {
                    case SkipQuantumEnum.MONTHS:
                    case SkipQuantumEnum.QUARTERS:
                    case SkipQuantumEnum.YEARS:
                        Logger.Current.Debug("times.interval", () => "stabilize: monthly, quarterly or yearly duration");
                        // These start on most recent period start quantum before when
                        // DEBUG("times.interval", "stabilize: monthly, quarterly or yearly duration");
                        Start = DateDuration.FindNearest(when, Duration.Quantum);
                        break;

                    case SkipQuantumEnum.WEEKS:
                        // Weeks start on the beginning of week prior to 400 remainder period length
                        // Either the first quanta of the period or the last quanta of the period seems more sensible
                        // implies period is never less than 400 days not too unreasonable
                        // DEBUG("times.interval", "stabilize: weekly duration");
                        Logger.Current.Debug("times.interval", () => "stabilize: weekly duration");
                        int period = Duration.Length * 7;
                        Start = DateDuration.FindNearest(when.AddDays(-(period + 400 % period)), Duration.Quantum);
                        break;

                    default:
                        // multiples of days have a quanta of 1 day so should not have the start date adjusted to a quanta
                        Logger.Current.Debug("times.interval", () => "stabilize: daily duration - stable by definition");
                        Start = when;
                        break;
                    }
                    Logger.Current.Debug("times.interval", () => String.Format("stabilize: beginning start date = {0}", Start));

                    while (Start < date)
                    {
                        DateInterval nextInterval = new DateInterval(this);
                        nextInterval++;

                        if (nextInterval.Start.HasValue && nextInterval.Start <= date)
                        {
                            Assign(nextInterval);
                        }
                        else
                        {
                            EndOfDuration = null;
                            Next          = null;
                            break;
                        }
                    }

                    Logger.Current.Debug("times.interval", () => String.Format("stabilize: proposed start date = {0}", Start));

                    if (initialStart.HasValue && (!Start.HasValue || Start < initialStart))
                    {
                        // Using the discovered start, find the end of the period
                        ResolveEnd();
                        Start = initialStart;
                        Logger.Current.Debug("times.interval", () => "stabilize: start reset to initial start");
                    }
                    if (initialFinish.HasValue && (!Finish.HasValue || Finish > initialFinish))
                    {
                        Finish = initialFinish;
                        Logger.Current.Debug("times.interval", () => "stabilize: finish reset to initial finish");
                    }

                    if (Start.HasValue)
                    {
                        Logger.Current.Debug("times.interval", () => String.Format("stabilize: final start  = {0}", Start));
                    }
                    if (Finish.HasValue)
                    {
                        Logger.Current.Debug("times.interval", () => String.Format("stabilize: final finish = {0}", Finish));
                    }
                }
                else if (Range != null)
                {
                    Start  = Range.Begin;
                    Finish = Range.End;
                }
                Aligned = true;
            }

            // If there is no duration, then if we've reached here the date falls
            // between start and finish.
            if (Duration == null)
            {
                Logger.Current.Debug("times.interval", () => "stabilize: there was no duration given");
                if (!Start.HasValue && !Finish.HasValue)
                {
                    throw new DateError(DateError.ErrorMessageInvalidDateIntervalNeitherStartNorFinishNorDuration);
                }
            }
            else
            {
                ResolveEnd();
            }
        }
Exemple #3
0
        /// <summary>
        /// Ported from date_parser_t::parse()
        /// </summary>
        public DateInterval Parse()
        {
            DateSpecifier sinceSpecifier     = null;
            DateSpecifier untilSpecifier     = null;
            DateSpecifier inclusionSpecifier = null;

            DateInterval period       = new DateInterval();
            Date         today        = TimesCommon.Current.CurrentDate;
            bool         endInclusive = false;

            for (LexerToken tok = Lexer.NextToken(); tok.Kind != LexerTokenKindEnum.END_REACHED; tok = Lexer.NextToken())
            {
                switch (tok.Kind)
                {
                case LexerTokenKindEnum.TOK_DATE:
                case LexerTokenKindEnum.TOK_INT:
                case LexerTokenKindEnum.TOK_A_MONTH:
                case LexerTokenKindEnum.TOK_A_WDAY:
                    DetermineWhen(ref tok, ref inclusionSpecifier);
                    break;

                case LexerTokenKindEnum.TOK_DASH:
                    if (inclusionSpecifier != null)
                    {
                        sinceSpecifier     = inclusionSpecifier;
                        inclusionSpecifier = null;
                        tok = Lexer.NextToken();
                        DetermineWhen(ref tok, ref untilSpecifier);

                        // The dash operator is special: it has an _inclusive_ end.
                        endInclusive = true;
                    }
                    else
                    {
                        tok.Unexpected();
                    }
                    break;

                case LexerTokenKindEnum.TOK_SINCE:
                    if (sinceSpecifier != null)
                    {
                        tok.Unexpected();
                    }
                    else
                    {
                        tok = Lexer.NextToken();
                        DetermineWhen(ref tok, ref sinceSpecifier);
                    }
                    break;

                case LexerTokenKindEnum.TOK_UNTIL:
                    if (untilSpecifier != null)
                    {
                        tok.Unexpected();
                    }
                    else
                    {
                        tok = Lexer.NextToken();
                        DetermineWhen(ref tok, ref untilSpecifier);
                    }
                    break;

                case LexerTokenKindEnum.TOK_IN:
                    if (inclusionSpecifier != null)
                    {
                        tok.Unexpected();
                    }
                    else
                    {
                        tok = Lexer.NextToken();
                        DetermineWhen(ref tok, ref inclusionSpecifier);
                    }
                    break;

                case LexerTokenKindEnum.TOK_THIS:
                case LexerTokenKindEnum.TOK_NEXT:
                case LexerTokenKindEnum.TOK_LAST:
                {
                    int adjust = 0;
                    if (tok.Kind == LexerTokenKindEnum.TOK_NEXT)
                    {
                        adjust = 1;
                    }
                    else if (tok.Kind == LexerTokenKindEnum.TOK_LAST)
                    {
                        adjust = -1;
                    }

                    tok = Lexer.NextToken();
                    switch (tok.Kind)
                    {
                    case LexerTokenKindEnum.TOK_INT:
                    {
                        int amount = tok.Value.GetValue <int>();

                        Date baseDate = today;
                        Date end      = today;

                        if (adjust == 0)
                        {
                            adjust = 1;
                        }

                        tok = Lexer.NextToken();
                        switch (tok.Kind)
                        {
                        case LexerTokenKindEnum.TOK_YEARS:
                            baseDate = baseDate.AddYears(amount * adjust);
                            break;

                        case LexerTokenKindEnum.TOK_QUARTERS:
                            baseDate = baseDate.AddMonths(amount * adjust * 3);
                            break;

                        case LexerTokenKindEnum.TOK_MONTHS:
                            baseDate = baseDate.AddMonths(amount * adjust);
                            break;

                        case LexerTokenKindEnum.TOK_WEEKS:
                            baseDate = baseDate.AddDays(amount * adjust * 7);
                            break;

                        case LexerTokenKindEnum.TOK_DAYS:
                            baseDate = baseDate.AddDays(amount * adjust);
                            break;

                        default:
                            tok.Unexpected();
                            break;
                        }

                        if (adjust > 0)
                        {
                            Date temp = baseDate;
                            baseDate = end;
                            end      = temp;
                        }

                        sinceSpecifier = new DateSpecifier(baseDate);
                        untilSpecifier = new DateSpecifier(end);
                        break;
                    }

                    case LexerTokenKindEnum.TOK_A_MONTH:
                    {
                        DetermineWhen(ref tok, ref inclusionSpecifier);

                        Date temp = new Date(today.Year, (int)inclusionSpecifier.Month, 1);
                        temp = temp.AddYears(adjust);
                        inclusionSpecifier = new DateSpecifier(temp.Year, (MonthEnum)temp.Month);
                        break;
                    }

                    case LexerTokenKindEnum.TOK_A_WDAY:
                    {
                        DetermineWhen(ref tok, ref inclusionSpecifier);

                        Date temp = DateDuration.FindNearest(today, SkipQuantumEnum.WEEKS);
                        while (temp.DayOfWeek != inclusionSpecifier.WDay)
                        {
                            temp = temp.AddDays(1);
                        }
                        temp = temp.AddDays(7 * adjust);
                        inclusionSpecifier = new DateSpecifier(temp);
                        break;
                    }

                    case LexerTokenKindEnum.TOK_YEAR:
                    {
                        Date temp = today;
                        temp = temp.AddYears(adjust);
                        inclusionSpecifier = new DateSpecifier(temp.Year);
                        break;
                    }

                    case LexerTokenKindEnum.TOK_QUARTER:
                    {
                        Date baseDate = DateDuration.FindNearest(today, SkipQuantumEnum.QUARTERS);
                        Date temp;
                        if (adjust < 0)
                        {
                            temp = baseDate.AddMonths(3 * adjust);
                        }
                        else if (adjust == 0)
                        {
                            temp = baseDate.AddMonths(3);
                        }
                        else
                        {
                            baseDate = baseDate.AddMonths(3 * adjust);
                            temp     = baseDate.AddMonths(3 * adjust);
                        }
                        sinceSpecifier = new DateSpecifier(adjust < 0 ? temp : baseDate);
                        untilSpecifier = new DateSpecifier(adjust < 0 ? baseDate : temp);
                        break;
                    }

                    case LexerTokenKindEnum.TOK_WEEK:
                    {
                        Date baseDate = DateDuration.FindNearest(today, SkipQuantumEnum.WEEKS);
                        Date temp;
                        if (adjust < 0)
                        {
                            temp = baseDate.AddDays(7 * adjust);
                        }
                        else if (adjust == 0)
                        {
                            temp = baseDate.AddDays(7);
                        }
                        else
                        {
                            baseDate = baseDate.AddDays(7 * adjust);
                            temp     = baseDate.AddDays(7 * adjust);
                        }
                        sinceSpecifier = new DateSpecifier(adjust < 0 ? temp : baseDate);
                        untilSpecifier = new DateSpecifier(adjust < 0 ? baseDate : temp);
                        break;
                    }

                    case LexerTokenKindEnum.TOK_DAY:
                    {
                        Date temp = today;
                        temp = temp.AddDays(adjust);
                        inclusionSpecifier = new DateSpecifier(temp);
                        break;
                    }

                    case LexerTokenKindEnum.TOK_MONTH:
                    default:
                    {
                        Date temp = today;
                        temp = temp.AddMonths(adjust);
                        inclusionSpecifier = new DateSpecifier(temp.Year, (MonthEnum)temp.Month);
                        break;
                    }
                    }
                    break;
                }

                case LexerTokenKindEnum.TOK_TODAY:
                    inclusionSpecifier = new DateSpecifier(today);
                    break;

                case LexerTokenKindEnum.TOK_TOMORROW:
                    inclusionSpecifier = new DateSpecifier(today.AddDays(1));
                    break;

                case LexerTokenKindEnum.TOK_YESTERDAY:
                    inclusionSpecifier = new DateSpecifier(today.AddDays(-1));
                    break;

                case LexerTokenKindEnum.TOK_EVERY:
                    tok = Lexer.NextToken();
                    if (tok.Kind == LexerTokenKindEnum.TOK_INT)
                    {
                        int quantity = tok.Value.GetValue <int>();
                        tok = Lexer.NextToken();
                        switch (tok.Kind)
                        {
                        case LexerTokenKindEnum.TOK_YEARS:
                            period.Duration = new DateDuration(SkipQuantumEnum.YEARS, quantity);
                            break;

                        case LexerTokenKindEnum.TOK_QUARTERS:
                            period.Duration = new DateDuration(SkipQuantumEnum.QUARTERS, quantity);
                            break;

                        case LexerTokenKindEnum.TOK_MONTHS:
                            period.Duration = new DateDuration(SkipQuantumEnum.MONTHS, quantity);
                            break;

                        case LexerTokenKindEnum.TOK_WEEKS:
                            period.Duration = new DateDuration(SkipQuantumEnum.WEEKS, quantity);
                            break;

                        case LexerTokenKindEnum.TOK_DAYS:
                            period.Duration = new DateDuration(SkipQuantumEnum.DAYS, quantity);
                            break;

                        default:
                            tok.Unexpected();
                            break;
                        }
                    }
                    else
                    {
                        switch (tok.Kind)
                        {
                        case LexerTokenKindEnum.TOK_YEAR:
                            period.Duration = new DateDuration(SkipQuantumEnum.YEARS, 1);
                            break;

                        case LexerTokenKindEnum.TOK_QUARTER:
                            period.Duration = new DateDuration(SkipQuantumEnum.QUARTERS, 1);
                            break;

                        case LexerTokenKindEnum.TOK_MONTH:
                            period.Duration = new DateDuration(SkipQuantumEnum.MONTHS, 1);
                            break;

                        case LexerTokenKindEnum.TOK_WEEK:
                            period.Duration = new DateDuration(SkipQuantumEnum.WEEKS, 1);
                            break;

                        case LexerTokenKindEnum.TOK_DAY:
                            period.Duration = new DateDuration(SkipQuantumEnum.DAYS, 1);
                            break;

                        default:
                            tok.Unexpected();
                            break;
                        }
                    }
                    break;

                case LexerTokenKindEnum.TOK_YEARLY:
                    period.Duration = new DateDuration(SkipQuantumEnum.YEARS, 1);
                    break;

                case LexerTokenKindEnum.TOK_QUARTERLY:
                    period.Duration = new DateDuration(SkipQuantumEnum.QUARTERS, 1);
                    break;

                case LexerTokenKindEnum.TOK_BIMONTHLY:
                    period.Duration = new DateDuration(SkipQuantumEnum.MONTHS, 2);
                    break;

                case LexerTokenKindEnum.TOK_MONTHLY:
                    period.Duration = new DateDuration(SkipQuantumEnum.MONTHS, 1);
                    break;

                case LexerTokenKindEnum.TOK_BIWEEKLY:
                    period.Duration = new DateDuration(SkipQuantumEnum.WEEKS, 2);
                    break;

                case LexerTokenKindEnum.TOK_WEEKLY:
                    period.Duration = new DateDuration(SkipQuantumEnum.WEEKS, 1);
                    break;

                case LexerTokenKindEnum.TOK_DAILY:
                    period.Duration = new DateDuration(SkipQuantumEnum.DAYS, 1);
                    break;

                default:
                    tok.Unexpected();
                    break;
                }
            }

            if (sinceSpecifier != null || untilSpecifier != null)
            {
                DateRange range = new DateRange(sinceSpecifier, untilSpecifier)
                {
                    EndExclusive = endInclusive
                };
                period.Range = new DateSpecifierOrRange(range);
            }
            else if (inclusionSpecifier != null)
            {
                period.Range = new DateSpecifierOrRange(inclusionSpecifier);
            }
            else
            {
                /* otherwise, it's something like "monthly", with no date reference */
            }

            return(period);
        }