Пример #1
0
        static public bool TryParse(string s, ExpressionSectionType type, out ListExpressionSection result)
        {
            result = default(ListExpressionSection);
            if (string.IsNullOrEmpty(s)) return false;

            string[] parts = s.Split(',');
            if (parts.Length <= 1) return false;
            var sections = new List<ExpressionSectionBase>();

            foreach (string part in parts)
            {
                if (string.IsNullOrEmpty(part)) return false;
                if (part.Contains(",")) return false;
                if (part.Contains("/")) return false;
                if (part.Contains("-")) return false;
                if (part.Contains("?")) return false;

                ExpressionSectionBase section;
                if (!TryParse(part, type, out section)) return false;
                sections.Add(section);
            }

            result = new ListExpressionSection();
            result.Type = type;
            result._sections.AddRange(sections);

            return true;
        }
        static public bool TryParse(string s, ExpressionSectionType type, out ListExpressionSection result)
        {
            result = default(ListExpressionSection);
            if (string.IsNullOrEmpty(s)) return false;

            string[] parts = s.Split(',');
            if (parts.Length <= 1) return false;
            var sections = new List<ExpressionSectionBase>();

            foreach (string part in parts)
            {
                if (string.IsNullOrEmpty(part)) return false;
                if (part.Contains(",")) return false;
                if (part.Contains("/")) return false;
                if (part.Contains("-")) return false;
                if (part.Contains("?")) return false;

                ExpressionSectionBase section;
                if (!TryParse(part, type, out section)) return false;
                sections.Add(section);
            }

            result = new ListExpressionSection();
            result.Type = type;
            result._sections.AddRange(sections);

            return true;
        }
        static public bool TryParse(string s, ExpressionSectionType type, out ExpressionSectionBase result)
        {
            result = default(ExpressionSectionBase);

            if (string.IsNullOrEmpty(s))
            {
                return(false);
            }

            EveryOccurenceExpressionSection every;

            if (EveryOccurenceExpressionSection.TryParse(s, type, out every))
            {
                result = every;
                return(true);
            }
            IgnoreExpressionSection ignore;

            if (IgnoreExpressionSection.TryParse(s, type, out ignore))
            {
                if (type != ExpressionSectionType.DayOfMonth && type != ExpressionSectionType.DayOfWeek)
                {
                    return(false);
                }
                result = ignore;
                return(true);
            }

            RangeExpressionSection range;

            if (RangeExpressionSection.TryParse(s, type, out range))
            {
                result = range;
                return(true);
            }

            RepeatingExpressionSection repeating;

            if (RepeatingExpressionSection.TryParse(s, type, out repeating))
            {
                result = repeating;
                return(true);
            }

            ListExpressionSection list;

            if (ListExpressionSection.TryParse(s, type, out list))
            {
                result = list;
                return(true);
            }

            switch (type)
            {
            case ExpressionSectionType.Month:
                MonthExpressionSection month;
                if (!MonthExpressionSection.TryParse(s, out month))
                {
                    return(false);
                }
                result = month;
                return(true);

            case ExpressionSectionType.DayOfWeek:
                DayOfWeekExpressionSection dayOfWeek;
                if (DayOfWeekExpressionSection.TryParse(s, out dayOfWeek))
                {
                    result = dayOfWeek;
                    return(true);
                }
                SpecifiedWeekAndWeekDayExpressionSection specifiedDayAndWeekDay;
                if (SpecifiedWeekAndWeekDayExpressionSection.TryParse(s, out specifiedDayAndWeekDay))
                {
                    result = specifiedDayAndWeekDay;
                    return(true);
                }
                goto default;

            case ExpressionSectionType.DayOfMonth:
                LastDayOfMonthExpressionSection lastDayOfMonth;
                if (LastDayOfMonthExpressionSection.TryParse(s, out lastDayOfMonth))
                {
                    result = lastDayOfMonth;
                    return(true);
                }
                NearestWeekdayExpressionSection nearestWeekDay;
                if (NearestWeekdayExpressionSection.TryParse(s, out nearestWeekDay))
                {
                    result = nearestWeekDay;
                    return(true);
                }
                LastWeekDayOfMonthExpressionSection lastWeekDay;
                if (LastWeekDayOfMonthExpressionSection.TryParse(s, out lastWeekDay))
                {
                    result = lastWeekDay;
                    return(true);
                }
                goto default;

            default:
                SimpleExpressionSection simple;
                if (!SimpleExpressionSection.TryParse(s, type, out simple))
                {
                    return(false);
                }
                result = simple;
                return(true);
            }
        }