コード例 #1
0
ファイル: ScheduleParser.cs プロジェクト: djMax/AlienForce
        private static ScheduleRule ConvertHourTokenToRule(RuleDayOfWeek days, ScheduleToken hourToken)
        {
            switch (hourToken.Type)
            {
                case ScheduleTokenType.AllDay:
                case ScheduleTokenType.HourRange:
                    byte startHour = hourToken.StartHour.Value;
                    if (hourToken.StartMeridiem != HourMeridiem.None)
                    {
                        if (hourToken.StartMeridiem == HourMeridiem.AM)
                        {
                            if (startHour == 12)
                            {
                                startHour = 0;
                            }
                        }
                        else if (startHour > 0 && startHour < 12)
                        {
                            startHour += 12;
                        }
                    }
                    else if (startHour == 24)
                    {
                        startHour = 0;
                    }
                    short startMinute = (short)((startHour * 60) + (hourToken.StartMinute ?? 0));

                    byte endHour = hourToken.EndHour.Value;
                    if (hourToken.EndMeridiem != HourMeridiem.None)
                    {
                        if (hourToken.EndMeridiem == HourMeridiem.AM)
                        {
                            if (endHour == 12)
                            {
                                endHour = 0;
                            }
                        }
                        else if (endHour > 0 && endHour < 12)
                        {
                            endHour += 12;
                        }
                    }
                    else if (endHour == 24)
                    {
                        endHour = 0;
                    }
                    short endMinute = (short)((endHour * 60) + (hourToken.EndMinute ?? 0));
                    if (hourToken.EndMeridiem == HourMeridiem.PM && hourToken.StartMeridiem == HourMeridiem.None && (startMinute + (12 * 60)) < endMinute && startMinute < 1440)
                    {
                        startMinute += (12 * 60);
                    }
                    else if (hourToken.EndMeridiem == HourMeridiem.None && startMinute > endMinute && startMinute < 720 && endMinute < 720)
                    {
                        endMinute += (12 * 60);
                    }
                    return new ScheduleRule(days, startMinute, endMinute);
            }
            return null;
        }
コード例 #2
0
ファイル: ScheduleParser.cs プロジェクト: djMax/AlienForce
 private static void ParseUntilTimeGroup(List<ScheduleToken> tokens, Match m)
 {
     byte untilHour, untilMinute;
     HourMeridiem untilMeridiem;
     ParseTime(m, "UntilHour", "UntilMinute", "UntilMeridiem", "UntilTime", out untilHour, out untilMinute, out untilMeridiem);
     ScheduleToken untilToken = new ScheduleToken(ScheduleTokenType.Until);
     untilToken.EndHour = untilHour;
     untilToken.EndMinute = untilMinute;
     untilToken.EndMeridiem = untilMeridiem;
     tokens.Add(untilToken);
 }
コード例 #3
0
ファイル: ScheduleParser.cs プロジェクト: djMax/AlienForce
        public Schedule Parse(string s)
        {
            Console.WriteLine(s);
            s = s.ToLowerInvariant();
            s = mDottedMeridiemPattern.Replace(s, delegate(Match meridienMatch)
            {
                Group am = meridienMatch.Groups["AM"];
                Group pm = meridienMatch.Groups["PM"];
                if (am.Success)
                {
                    return "am";
                }
                if (pm.Success)
                {
                    return "pm";
                }
                return meridienMatch.Value;
            });
            Console.WriteLine(s);
            List<ScheduleToken> tokens = new List<ScheduleToken>();
            Match m = mHoursPattern.Match(s);
            if (m.Success)
            {
                do
                {
                    Console.WriteLine("\t{0}", m.Value);
                    Group g = m.Groups["AllDay"];
                    if (g.Success)
                    {
                        ScheduleToken allDayToken = new ScheduleToken(ScheduleTokenType.AllDay);
                        allDayToken.StartHour = 0;
                        allDayToken.EndHour = 0;
                        tokens.Add(allDayToken);
                        continue;
                    }
                    g = m.Groups["Days"];
                    if (g.Success)
                    {
                        ParseDaysGroup(tokens, m, g);
                        continue;
                    }
                    g = m.Groups["Hours"];
                    if (g.Success)
                    {
                        ParseHoursGroup(tokens, m);
                        continue;
                    }
                    g = m.Groups["UntilTime"];
                    if (g.Success)
                    {
                        ParseUntilTimeGroup(tokens, m);
                        continue;
                    }
                    g = m.Groups["MonthSpan"];
                    if (g.Success)
                    {
                        ParseMonthSpanGroup(tokens, m);
                        continue;
                    }
                    g = m.Groups["DateSpan"];
                    if (g.Success)
                    {
                        ParseDateSpanGroup(tokens, m);
                        continue;
                    }
                    g = m.Groups["SingleMonth"];
                    if (g.Success)
                    {
                        ParseSingleMonthGroup(tokens, m);
                        continue;
                    }
                    g = m.Groups["Separator"];
                    if (g.Success)
                    {
                        tokens.Add(new ScheduleToken(ScheduleTokenType.Separator));
                        continue;
                    }
                    g = m.Groups["Closed"];
                    if (g.Success)
                    {
                        tokens.Add(new ScheduleToken(ScheduleTokenType.Closed));
                        continue;
                    }
                    g = m.Groups["Open"];
                    if (g.Success)
                    {
                        tokens.Add(new ScheduleToken(ScheduleTokenType.Open));
                        continue;
                    }

                }
                while ((m = m.NextMatch()) != null && m.Success);
            }
            PrintTokens(tokens);
            string leftovers = mHoursPattern.Replace(s, string.Empty).Trim();
            if (leftovers.Length > 0)
            {
                Console.WriteLine("Leftovers: {0}", leftovers);
            }
            Schedule schedule = ConvertTokensToSchedule(tokens);
            if (schedule != null)
            {
                StringBuilder sb = new StringBuilder();
                sb.AppendLine("Schedule:");
                foreach (ScheduleRuleSpan rule in schedule.mPositiveRules)
                {
                    sb.Append("\t");
                    rule.ToString(sb);
                    sb.AppendLine();
                }
                sb.AppendLine("Negative");
                foreach (ScheduleRuleSpan rule in schedule.mNegativeRules)
                {
                    sb.Append("\t");
                    rule.ToString(sb);
                    sb.AppendLine();
                }
                Console.WriteLine(sb.ToString());
            }
            return schedule;
        }