/Cron.NET/CronExpression.cs

Large files files are truncated, but you can click here to view the full file

/* 

* Copyright 2004-2009 James House 

* 

* Licensed under the Apache License, Version 2.0 (the "License"); you may not 

* use this file except in compliance with the License. You may obtain a copy 

* of the License at 

* 

*   http://www.apache.org/licenses/LICENSE-2.0 

*   

* Unless required by applicable law or agreed to in writing, software 

* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT 

* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the 

* License for the specific language governing permissions and limitations 

* under the License.

* 

*/

using System;

using System.Collections;

using System.Globalization;

using System.Runtime.Serialization;

using System.Text;





using NullableDateTime = System.Nullable<System.DateTime>;







//using TimeZone = System.TimeZoneInfo;





using Quartz.Collection;



namespace Quartz

{

    /// <summary>

    /// Provides a parser and evaluator for unix-like cron expressions. Cron 

    /// expressions provide the ability to specify complex time combinations such as

    /// &quot;At 8:00am every Monday through Friday&quot; or &quot;At 1:30am every 

    /// last Friday of the month&quot;. 

    /// </summary>

    /// <remarks>

    /// <p>

    /// Cron expressions are comprised of 6 required fields and one optional field

    /// separated by white space. The fields respectively are described as follows:

    /// </p>

    /// <table cellspacing="8">

    /// <tr>

    /// <th align="left">Field Name</th>

    /// <th align="left"> </th>

    /// <th align="left">Allowed Values</th>

    /// <th align="left"> </th>

    /// <th align="left">Allowed Special Characters</th>

    /// </tr>

    /// <tr>

    /// <td align="left">Seconds</td>

    /// <td align="left"> </td>

    /// <td align="left">0-59</td>

    /// <td align="left"> </td>

    /// <td align="left">, - /// /</td>

    /// </tr>

    /// <tr>

    /// <td align="left">Minutes</td>

    /// <td align="left"> </td>

    /// <td align="left">0-59</td>

    /// <td align="left"> </td>

    /// <td align="left">, - /// /</td>

    /// </tr>

    /// <tr>

    /// <td align="left">Hours</td>

    /// <td align="left"> </td>

    /// <td align="left">0-23</td>

    /// <td align="left"> </td>

    /// <td align="left">, - /// /</td>

    /// </tr>

    /// <tr>

    /// <td align="left">Day-of-month</td>

    /// <td align="left"> </td>

    /// <td align="left">1-31</td>

    /// <td align="left"> </td>

    /// <td align="left">, - /// ? / L W C</td>

    /// </tr>

    /// <tr>

    /// <td align="left">Month</td>

    /// <td align="left"> </td>

    /// <td align="left">1-12 or JAN-DEC</td>

    /// <td align="left"> </td>

    /// <td align="left">, - /// /</td>

    /// </tr>

    /// <tr>

    /// <td align="left">Day-of-Week</td>

    /// <td align="left"> </td>

    /// <td align="left">1-7 or SUN-SAT</td>

    /// <td align="left"> </td>

    /// <td align="left">, - /// ? / L #</td>

    /// </tr>

    /// <tr>

    /// <td align="left">Year (Optional)</td>

    /// <td align="left"> </td>

    /// <td align="left">empty, 1970-2099</td>

    /// <td align="left"> </td>

    /// <td align="left">, - /// /</td>

    /// </tr>

    /// </table>

    /// <p>

    /// The '*' character is used to specify all values. For example, &quot;*&quot; 

    /// in the minute field means &quot;every minute&quot;.

    /// </p>

    /// <p>

    /// The '?' character is allowed for the day-of-month and day-of-week fields. It

    /// is used to specify 'no specific value'. This is useful when you need to

    /// specify something in one of the two fields, but not the other.

    /// </p>

    /// <p>

    /// The '-' character is used to specify ranges For example &quot;10-12&quot; in

    /// the hour field means &quot;the hours 10, 11 and 12&quot;.

    /// </p>

    /// <p>

    /// The ',' character is used to specify additional values. For example

    /// &quot;MON,WED,FRI&quot; in the day-of-week field means &quot;the days Monday,

    /// Wednesday, and Friday&quot;.

    /// </p>

    /// <p>

    /// The '/' character is used to specify increments. For example &quot;0/15&quot;

    /// in the seconds field means &quot;the seconds 0, 15, 30, and 45&quot;. And 

    /// &quot;5/15&quot; in the seconds field means &quot;the seconds 5, 20, 35, and

    /// 50&quot;.  Specifying '*' before the  '/' is equivalent to specifying 0 is

    /// the value to start with. Essentially, for each field in the expression, there

    /// is a set of numbers that can be turned on or off. For seconds and minutes, 

    /// the numbers range from 0 to 59. For hours 0 to 23, for days of the month 0 to

    /// 31, and for months 1 to 12. The &quot;/&quot; character simply helps you turn

    /// on every &quot;nth&quot; value in the given set. Thus &quot;7/6&quot; in the

    /// month field only turns on month &quot;7&quot;, it does NOT mean every 6th 

    /// month, please note that subtlety.  

    /// </p>

    /// <p>

    /// The 'L' character is allowed for the day-of-month and day-of-week fields.

    /// This character is short-hand for &quot;last&quot;, but it has different 

    /// meaning in each of the two fields. For example, the value &quot;L&quot; in 

    /// the day-of-month field means &quot;the last day of the month&quot; - day 31 

    /// for January, day 28 for February on non-leap years. If used in the 

    /// day-of-week field by itself, it simply means &quot;7&quot; or 

    /// &quot;SAT&quot;. But if used in the day-of-week field after another value, it

    /// means &quot;the last xxx day of the month&quot; - for example &quot;6L&quot;

    /// means &quot;the last friday of the month&quot;. When using the 'L' option, it

    /// is important not to specify lists, or ranges of values, as you'll get 

    /// confusing results.

    /// </p>

    /// <p>

    /// The 'W' character is allowed for the day-of-month field.  This character 

    /// is used to specify the weekday (Monday-Friday) nearest the given day.  As an 

    /// example, if you were to specify &quot;15W&quot; as the value for the 

    /// day-of-month field, the meaning is: &quot;the nearest weekday to the 15th of

    /// the month&quot;. So if the 15th is a Saturday, the trigger will fire on 

    /// Friday the 14th. If the 15th is a Sunday, the trigger will fire on Monday the

    /// 16th. If the 15th is a Tuesday, then it will fire on Tuesday the 15th. 

    /// However if you specify &quot;1W&quot; as the value for day-of-month, and the

    /// 1st is a Saturday, the trigger will fire on Monday the 3rd, as it will not 

    /// 'jump' over the boundary of a month's days.  The 'W' character can only be 

    /// specified when the day-of-month is a single day, not a range or list of days.

    /// </p>

    /// <p>

    /// The 'L' and 'W' characters can also be combined for the day-of-month 

    /// expression to yield 'LW', which translates to &quot;last weekday of the 

    /// month&quot;.

    /// </p>

    /// <p>

    /// The '#' character is allowed for the day-of-week field. This character is

    /// used to specify &quot;the nth&quot; XXX day of the month. For example, the 

    /// value of &quot;6#3&quot; in the day-of-week field means the third Friday of 

    /// the month (day 6 = Friday and &quot;#3&quot; = the 3rd one in the month). 

    /// Other examples: &quot;2#1&quot; = the first Monday of the month and 

    /// &quot;4#5&quot; = the fifth Wednesday of the month. Note that if you specify

    /// &quot;#5&quot; and there is not 5 of the given day-of-week in the month, then

    /// no firing will occur that month. If the '#' character is used, there can

    /// only be one expression in the day-of-week field (&quot;3#1,6#3&quot; is 

    /// not valid, since there are two expressions).

    /// </p>

    /// <p>

    /// <!--The 'C' character is allowed for the day-of-month and day-of-week fields.

    /// This character is short-hand for "calendar". This means values are

    /// calculated against the associated calendar, if any. If no calendar is

    /// associated, then it is equivalent to having an all-inclusive calendar. A

    /// value of "5C" in the day-of-month field means "the first day included by the

    /// calendar on or after the 5th". A value of "1C" in the day-of-week field

    /// means "the first day included by the calendar on or after sunday". -->

    /// </p>

    /// <p>

    /// The legal characters and the names of months and days of the week are not

    /// case sensitive.

    /// </p>

    /// <p>

    /// <b>NOTES:</b>

    /// <ul>

    /// <li>Support for specifying both a day-of-week and a day-of-month value is

    /// not complete (you'll need to use the '?' character in one of these fields).

    /// </li>

    /// <li>Overflowing ranges is supported - that is, having a larger number on 

    /// the left hand side than the right. You might do 22-2 to catch 10 o'clock 

    /// at night until 2 o'clock in the morning, or you might have NOV-FEB. It is 

    /// very important to note that overuse of overflowing ranges creates ranges 

    /// that don't make sense and no effort has been made to determine which 

    /// interpretation CronExpression chooses. An example would be 

    /// "0 0 14-6 ? * FRI-MON". </li>

    /// </ul>

    /// </p>

    /// </remarks>

    /// <author>Sharada Jambula</author>

    /// <author>James House</author>

    /// <author>Contributions from Mads Henderson</author>

    /// <author>Refactoring from CronTrigger to CronExpression by Aaron Craven</author>

    [Serializable]

    public class CronExpression : ICloneable, IDeserializationCallback

    {

		/// <summary>

		/// Field specification for second.

		/// </summary>

        protected const int Second = 0;



		/// <summary>

		/// Field specification for minute.

		/// </summary>

		protected const int Minute = 1;

        

		/// <summary>

		/// Field specification for hour.

		/// </summary>

		protected const int Hour = 2;

        

		/// <summary>

		/// Field specification for day of month.

		/// </summary>

		protected const int DayOfMonth = 3;

        

		/// <summary>

		/// Field specification for month.

		/// </summary>

		protected const int Month = 4;

        

		/// <summary>

		/// Field specification for day of week.

		/// </summary>

		protected const int DayOfWeek = 5;

        

		/// <summary>

		/// Field specification for year.

		/// </summary>

		protected const int Year = 6;

        

		/// <summary>

		/// Field specification for all wildcard value '*'.

		/// </summary>

		protected const int AllSpecInt = 99; // '*'

        

		/// <summary>

		/// Field specification for not specified value '?'.

		/// </summary>

		protected const int NoSpecInt = 98; // '?'

        

		/// <summary>

		/// Field specification for wildcard '*'.

		/// </summary>

		protected const int AllSpec = AllSpecInt;

		

		/// <summary>

		/// Field specification for no specification at all '?'.

		/// </summary>

		protected const int NoSpec = NoSpecInt;



        private static readonly Hashtable monthMap = new Hashtable(20);

        private static readonly Hashtable dayMap = new Hashtable(60);



        private readonly string cronExpressionString = null;

        

        private TimeZone timeZone = null;



        /// <summary>

        /// Seconds.

        /// </summary>

        [NonSerialized]

        protected TreeSet seconds;

        /// <summary>

        /// minutes.

        /// </summary>

        [NonSerialized]

        protected TreeSet minutes;

        /// <summary>

        /// Hours.

        /// </summary>

        [NonSerialized]

        protected TreeSet hours;

        /// <summary>

        /// Days of month.

        /// </summary>

        [NonSerialized]

        protected TreeSet daysOfMonth;

        /// <summary>

        /// Months.

        /// </summary>

        [NonSerialized]

        protected TreeSet months;

        /// <summary>

        /// Days of week.

        /// </summary>

        [NonSerialized]

        protected TreeSet daysOfWeek;

        /// <summary>

        /// Years.

        /// </summary>

        [NonSerialized]

        protected TreeSet years;



        /// <summary>

        /// Last day of week.

        /// </summary>

        [NonSerialized]

        protected bool lastdayOfWeek = false;

        /// <summary>

        /// Nth day of week.

        /// </summary>

        [NonSerialized]

        protected int nthdayOfWeek = 0;

        /// <summary>

        /// Last day of month.

        /// </summary>

        [NonSerialized]

        protected bool lastdayOfMonth = false;

        /// <summary>

        /// Nearest weekday.

        /// </summary>

        [NonSerialized]

        protected bool nearestWeekday = false;

        /// <summary>

        /// Calendar day of week.

        /// </summary>

        [NonSerialized]

        protected bool calendardayOfWeek = false;

        /// <summary>

        /// Calendar day of month.

        /// </summary>

        [NonSerialized]

        protected bool calendardayOfMonth = false;

        /// <summary>

        /// Expression parsed.

        /// </summary>

        [NonSerialized]

        protected bool expressionParsed = false;



        static CronExpression()

        {

            monthMap.Add("JAN", 0);

            monthMap.Add("FEB", 1);

            monthMap.Add("MAR", 2);

            monthMap.Add("APR", 3);

            monthMap.Add("MAY", 4);

            monthMap.Add("JUN", 5);

            monthMap.Add("JUL", 6);

            monthMap.Add("AUG", 7);

            monthMap.Add("SEP", 8);

            monthMap.Add("OCT", 9);

            monthMap.Add("NOV", 10);

            monthMap.Add("DEC", 11);



            dayMap.Add("SUN", 1);

            dayMap.Add("MON", 2);

            dayMap.Add("TUE", 3);

            dayMap.Add("WED", 4);

            dayMap.Add("THU", 5);

            dayMap.Add("FRI", 6);

            dayMap.Add("SAT", 7);

        }



        ///<summary>

        /// Constructs a new <see cref="CronExpressionString" /> based on the specified 

        /// parameter.

        /// </summary>

        /// <param name="cronExpression">

        /// String representation of the cron expression the new object should represent

        /// </param>

        /// <see cref="CronExpressionString" />

        public CronExpression(string cronExpression)

        {

            if (cronExpression == null)

            {

                throw new ArgumentException("cronExpression cannot be null");

            }



            cronExpressionString = cronExpression.ToUpper(CultureInfo.InvariantCulture);

            BuildExpression(cronExpression);

        }



        /// <summary>

        /// Indicates whether the given date satisfies the cron expression. 

        /// </summary>

        /// <remarks>

        /// Note that  milliseconds are ignored, so two Dates falling on different milliseconds

        /// of the same second will always have the same result here.

        /// </remarks>

        /// <param name="dateUtc">The date to evaluate.</param>

        /// <returns>a boolean indicating whether the given date satisfies the cron expression</returns>

        public virtual bool IsSatisfiedBy(DateTime dateUtc)

        {

            DateTime test =

                new DateTime(dateUtc.Year, dateUtc.Month, dateUtc.Day, dateUtc.Hour, dateUtc.Minute, dateUtc.Second).AddSeconds(-1);



            NullableDateTime timeAfter = GetTimeAfter(test);



            if (timeAfter.HasValue && timeAfter.Value.Equals(dateUtc))

            {

                return true;

            }

            else

            {

                return false;

            }

        }



        /// <summary>

        /// Returns the next date/time <i>after</i> the given date/time which

        /// satisfies the cron expression.

        /// </summary>

        /// <param name="date">the date/time at which to begin the search for the next valid date/time</param>

        /// <returns>the next valid date/time</returns>

        public virtual NullableDateTime GetNextValidTimeAfter(DateTime date)

        {

            return GetTimeAfter(date);

        }



        /// <summary>

        /// Returns the next date/time <i>after</i> the given date/time which does

        /// <i>not</i> satisfy the expression.

        /// </summary>

        /// <param name="date">the date/time at which to begin the search for the next invalid date/time</param>

        /// <returns>the next valid date/time</returns>

        public virtual NullableDateTime GetNextInvalidTimeAfter(DateTime date)

        {

            long difference = 1000;



            //move back to the nearest second so differences will be accurate

            DateTime lastDate =

                new DateTime(date.Year, date.Month, date.Day, date.Hour, date.Minute, date.Second).AddSeconds(-1);



            //TODO: IMPROVE THIS! The following is a BAD solution to this problem. Performance will be very bad here, depending on the cron expression. It is, however A solution.



            //keep getting the next included time until it's farther than one second

            // apart. At that point, lastDate is the last valid fire time. We return

            // the second immediately following it.

            while (difference == 1000)

            {

                DateTime newDate = GetTimeAfter(lastDate).Value;



                difference = (long) (newDate - lastDate).TotalMilliseconds;



                if (difference == 1000)

                {

                    lastDate = newDate;

                }

            }



            return lastDate.AddSeconds(1);

        }



        /// <summary>

        /// Sets or gets the time zone for which the <see cref="CronExpression" /> of this

        /// <see cref="CronTrigger" /> will be resolved.

        /// </summary>

        public virtual TimeZone TimeZone

        {

            set { timeZone = value; }

            get

            {

                if (timeZone == null)

                {

                    timeZone = TimeZone.CurrentTimeZone;

                }



                return timeZone;

            }

        }



        /// <summary>

        /// Returns the string representation of the <see cref="CronExpression" />

        /// </summary>

        /// <returns>The string representation of the <see cref="CronExpression" /></returns>

        public override string ToString()

        {

            return cronExpressionString;

        }



        /// <summary>

        /// Indicates whether the specified cron expression can be parsed into a 

        /// valid cron expression

        /// </summary>

        /// <param name="cronExpression">the expression to evaluate</param>

        /// <returns>a boolean indicating whether the given expression is a valid cron

        ///         expression</returns>

        public static bool IsValidExpression(string cronExpression)

        {

            try

            {

                new CronExpression(cronExpression);

            }

            catch (FormatException)

            {

                return false;

            }



            return true;

        }



        ////////////////////////////////////////////////////////////////////////////

        //

        // Expression Parsing Functions

        //

        ////////////////////////////////////////////////////////////////////////////



		/// <summary>

		/// Builds the expression.

		/// </summary>

		/// <param name="expression">The expression.</param>

        protected void BuildExpression(string expression)

        {

            expressionParsed = true;



            try

            {

                if (seconds == null)

                {

                    seconds = new TreeSet();

                }

                if (minutes == null)

                {

                    minutes = new TreeSet();

                }

                if (hours == null)

                {

                    hours = new TreeSet();

                }

                if (daysOfMonth == null)

                {

                    daysOfMonth = new TreeSet();

                }

                if (months == null)

                {

                    months = new TreeSet();

                }

                if (daysOfWeek == null)

                {

                    daysOfWeek = new TreeSet();

                }

                if (years == null)

                {

                    years = new TreeSet();

                }



                int exprOn = Second;



#if NET_20

                string[] exprsTok = expression.Trim().Split(new char[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);

#else

				string[] exprsTok = expression.Trim().Split(new char[] { ' ', '\t', '\r', '\n' });

#endif

                foreach (string exprTok in exprsTok)

                {

                    string expr = exprTok.Trim();



					if (expr.Length == 0)

					{

						continue;

					}

                    if (exprOn > Year)

                    {

                        break;

                    }



                    // throw an exception if L is used with other days of the month

                    if (exprOn == DayOfMonth && expr.IndexOf('L') != -1 && expr.Length > 1 && expr.IndexOf(",") >= 0)

                    {

                        throw new FormatException("Support for specifying 'L' and 'LW' with other days of the month is not implemented");

                    }

                    // throw an exception if L is used with other days of the week

                    if (exprOn == DayOfWeek && expr.IndexOf('L') != -1 && expr.Length > 1 && expr.IndexOf(",") >= 0)

                    {

                        throw new FormatException("Support for specifying 'L' with other days of the week is not implemented");

                    }



                    string[] vTok = expr.Split(',');

                    foreach (string v in vTok)

                    {

                        StoreExpressionVals(0, v, exprOn);

                    }



                    exprOn++;

                }



                if (exprOn <= DayOfWeek)

                {

                    throw new FormatException("Unexpected end of expression.");

                }



                if (exprOn <= Year)

                {

                    StoreExpressionVals(0, "*", Year);

                }



                TreeSet dow = GetSet(DayOfWeek);

                TreeSet dom = GetSet(DayOfMonth);



                // Copying the logic from the UnsupportedOperationException below

                bool dayOfMSpec = !dom.Contains(NoSpec);

                bool dayOfWSpec = !dow.Contains(NoSpec);



                if (dayOfMSpec && !dayOfWSpec)

                {

                    // skip

                }

                else if (dayOfWSpec && !dayOfMSpec)

                {

                    // skip

                }

                else

                {

                    throw new FormatException("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented.");

                }

            }

            catch (FormatException)

            {

                throw;

            }

            catch (Exception e)

            {

                throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Illegal cron expression format ({0})", e));

            }

        }



		/// <summary>

		/// Stores the expression values.

		/// </summary>

		/// <param name="pos">The position.</param>

		/// <param name="s">The string to traverse.</param>

		/// <param name="type">The type of value.</param>

		/// <returns></returns>

        protected virtual int StoreExpressionVals(int pos, string s, int type)

        {

            int incr = 0;

            int i = SkipWhiteSpace(pos, s);

            if (i >= s.Length)

            {

                return i;

            }

            char c = s[i];

            if ((c >= 'A') && (c <= 'Z') && (!s.Equals("L")) && (!s.Equals("LW")))

            {

                String sub = s.Substring(i, 3);

                int sval;

                int eval = -1;

                if (type == Month)

                {

                    sval = GetMonthNumber(sub) + 1;

                    if (sval <= 0)

                    {

                        throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Invalid Month value: '{0}'", sub));

                    }

                    if (s.Length > i + 3)

                    {

                        c = s[i + 3];

                        if (c == '-')

                        {

                            i += 4;

                            sub = s.Substring(i, 3);

                            eval = GetMonthNumber(sub) + 1;

                            if (eval <= 0)

                            {

                                throw new FormatException(

                                    string.Format(CultureInfo.InvariantCulture, "Invalid Month value: '{0}'", sub));

                            }

                        }

                    }

                }

                else if (type == DayOfWeek)

                {

                    sval = GetDayOfWeekNumber(sub);

                    if (sval < 0)

                    {

                        throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Invalid Day-of-Week value: '{0}'", sub));

                    }

                    if (s.Length > i + 3)

                    {

                        c = s[i + 3];

                        if (c == '-')

                        {

                            i += 4;

                            sub = s.Substring(i, 3);

                            eval = GetDayOfWeekNumber(sub);

                            if (eval < 0)

                            {

                                throw new FormatException(

                                    string.Format(CultureInfo.InvariantCulture, "Invalid Day-of-Week value: '{0}'", sub));

                            }

                        }

                        else if (c == '#')

                        {

                            try

                            {

                                i += 4;

                                nthdayOfWeek = Convert.ToInt32(s.Substring(i), CultureInfo.InvariantCulture);

                                if (nthdayOfWeek < 1 || nthdayOfWeek > 5)

                                {

                                    throw new Exception();

                                }

                            }

                            catch (Exception)

                            {

                                throw new FormatException(

                                    "A numeric value between 1 and 5 must follow the '#' option");

                            }

                        }

                        else if (c == 'L')

                        {

                            lastdayOfWeek = true;

                            i++;

                        }

                    }

                }

                else

                {

                    throw new FormatException(

                        string.Format(CultureInfo.InvariantCulture, "Illegal characters for this position: '{0}'", sub));

                }

                if (eval != -1)

                {

                    incr = 1;

                }

                AddToSet(sval, eval, incr, type);

                return (i + 3);

            }



            if (c == '?')

            {

                i++;

                if ((i + 1) < s.Length

                    && (s[i] != ' ' && s[i + 1] != '\t'))

                {

                    throw new FormatException("Illegal character after '?': "

                                              + s[i]);

                }

                if (type != DayOfWeek && type != DayOfMonth)

                {

                    throw new FormatException(

                        "'?' can only be specified for Day-of-Month or Day-of-Week.");

                }

                if (type == DayOfWeek && !lastdayOfMonth)

                {

                    int val = (int) daysOfMonth[daysOfMonth.Count - 1];

                    if (val == NoSpecInt)

                    {

                        throw new FormatException(

                            "'?' can only be specified for Day-of-Month -OR- Day-of-Week.");

                    }

                }



                AddToSet(NoSpecInt, -1, 0, type);

                return i;

            }



            if (c == '*' || c == '/')

            {

                if (c == '*' && (i + 1) >= s.Length)

                {

                    AddToSet(AllSpecInt, -1, incr, type);

                    return i + 1;

                }

                else if (c == '/'

                         && ((i + 1) >= s.Length || s[i + 1] == ' ' || s[i + 1] == '\t'))

                {

                    throw new FormatException("'/' must be followed by an integer.");

                }

                else if (c == '*')

                {

                    i++;

                }

                c = s[i];

                if (c == '/')

                {

                    // is an increment specified?

                    i++;

                    if (i >= s.Length)

                    {

                        throw new FormatException("Unexpected end of string.");

                    }



                    incr = GetNumericValue(s, i);



                    i++;

                    if (incr > 10)

                    {

                        i++;

                    }

                    if (incr > 59 && (type == Second || type == Minute))

                    {

                        throw new FormatException(

                            string.Format(CultureInfo.InvariantCulture, "Increment > 60 : {0}", incr));

                    }

                    else if (incr > 23 && (type == Hour))

                    {

                        throw new FormatException(

                            string.Format(CultureInfo.InvariantCulture, "Increment > 24 : {0}", incr));

                    }

                    else if (incr > 31 && (type == DayOfMonth))

                    {

                        throw new FormatException(

                            string.Format(CultureInfo.InvariantCulture, "Increment > 31 : {0}", incr));

                    }

                    else if (incr > 7 && (type == DayOfWeek))

                    {

                        throw new FormatException(

                            string.Format(CultureInfo.InvariantCulture, "Increment > 7 : {0}", incr));

                    }

                    else if (incr > 12 && (type == Month))

                    {

                        throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Increment > 12 : {0}", incr));

                    }

                }

                else

                {

                    incr = 1;

                }



                AddToSet(AllSpecInt, -1, incr, type);

                return i;

            }

            else if (c == 'L')

            {

                i++;

                if (type == DayOfMonth)

                {

                    lastdayOfMonth = true;

                }

                if (type == DayOfWeek)

                {

                    AddToSet(7, 7, 0, type);

                }

                if (type == DayOfMonth && s.Length > i)

                {

                    c = s[i];

                    if (c == 'W')

                    {

                        nearestWeekday = true;

                        i++;

                    }

                }

                return i;

            }

            else if (c >= '0' && c <= '9')

            {

                int val = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);

                i++;

                if (i >= s.Length)

                {

                    AddToSet(val, -1, -1, type);

                }

                else

                {

                    c = s[i];

                    if (c >= '0' && c <= '9')

                    {

                        ValueSet vs = GetValue(val, s, i);

                        val = vs.theValue;

                        i = vs.pos;

                    }

                    i = CheckNext(i, s, val, type);

                    return i;

                }

            }

            else

            {

                throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Unexpected character: {0}", c));

            }



            return i;

        }



		/// <summary>

		/// Checks the next value.

		/// </summary>

		/// <param name="pos">The position.</param>

		/// <param name="s">The string to check.</param>

		/// <param name="val">The value.</param>

		/// <param name="type">The type to search.</param>

		/// <returns></returns>

        protected virtual int CheckNext(int pos, string s, int val, int type)

        {

            int end = -1;

            int i = pos;



            if (i >= s.Length)

            {

                AddToSet(val, end, -1, type);

                return i;

            }



            char c = s[pos];



            if (c == 'L')

            {

                if (type == DayOfWeek)

                {

                    lastdayOfWeek = true;

                }

                else

                {

                    throw new FormatException(string.Format(CultureInfo.InvariantCulture, "'L' option is not valid here. (pos={0})", i));

                }

                TreeSet data = GetSet(type);

                data.Add(val);

                i++;

                return i;

            }



            if (c == 'W')

            {

                if (type == DayOfMonth)

                {

                    nearestWeekday = true;

                }

                else

                {

                    throw new FormatException(string.Format(CultureInfo.InvariantCulture, "'W' option is not valid here. (pos={0})", i));

                }

                TreeSet data = GetSet(type);

                data.Add(val);

                i++;

                return i;

            }



            if (c == '#')

            {

                if (type != DayOfWeek)

                {

                    throw new FormatException(

                        string.Format(CultureInfo.InvariantCulture, "'#' option is not valid here. (pos={0})", i));

                }

                i++;

                try

                {

                    nthdayOfWeek = Convert.ToInt32(s.Substring(i), CultureInfo.InvariantCulture);

                    if (nthdayOfWeek < 1 || nthdayOfWeek > 5)

                    {

                        throw new Exception();

                    }

                }

                catch (Exception)

                {

                    throw new FormatException(

                        "A numeric value between 1 and 5 must follow the '#' option");

                }



                TreeSet data = GetSet(type);

                data.Add(val);

                i++;

                return i;

            }



            if (c == 'C')

            {

                if (type == DayOfWeek)

                {

                    calendardayOfWeek = true;

                }

                else if (type == DayOfMonth)

                {

                    calendardayOfMonth = true;

                }

                else

                {

                    throw new FormatException(string.Format(CultureInfo.InvariantCulture, "'C' option is not valid here. (pos={0})", i));

                }

                TreeSet data = GetSet(type);

                data.Add(val);

                i++;

                return i;

            }



            if (c == '-')

            {

                i++;

                c = s[i];

                int v = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);

                end = v;

                i++;

                if (i >= s.Length)

                {

                    AddToSet(val, end, 1, type);

                    return i;

                }

                c = s[i];

                if (c >= '0' && c <= '9')

                {

                    ValueSet vs = GetValue(v, s, i);

                    int v1 = vs.theValue;

                    end = v1;

                    i = vs.pos;

                }

                if (i < s.Length && ((c = s[i]) == '/'))

                {

                    i++;

                    c = s[i];

                    int v2 = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);

                    i++;

                    if (i >= s.Length)

                    {

                        AddToSet(val, end, v2, type);

                        return i;

                    }

                    c = s[i];

                    if (c >= '0' && c <= '9')

                    {

                        ValueSet vs = GetValue(v2, s, i);

                        int v3 = vs.theValue;

                        AddToSet(val, end, v3, type);

                        i = vs.pos;

                        return i;

                    }

                    else

                    {

                        AddToSet(val, end, v2, type);

                        return i;

                    }

                }

                else

                {

                    AddToSet(val, end, 1, type);

                    return i;

                }

            }



            if (c == '/')

            {

                i++;

                c = s[i];

                int v2 = Convert.ToInt32(c.ToString(), CultureInfo.InvariantCulture);

                i++;

                if (i >= s.Length)

                {

                    AddToSet(val, end, v2, type);

                    return i;

                }

                c = s[i];

                if (c >= '0' && c <= '9')

                {

                    ValueSet vs = GetValue(v2, s, i);

                    int v3 = vs.theValue;

                    AddToSet(val, end, v3, type);

                    i = vs.pos;

                    return i;

                }

                else

                {

                    throw new FormatException(string.Format(CultureInfo.InvariantCulture, "Unexpected character '{0}' after '/'", c));

                }

            }



            AddToSet(val, end, 0, type);

            i++;

            return i;

        }



		/// <summary>

		/// Gets the cron expression string.

		/// </summary>

		/// <value>The cron expression string.</value>

        public string CronExpressionString

        {

            get { return cronExpressionString; }

        }



		/// <summary>

		/// Gets the expression summary.

		/// </summary>

		/// <returns></returns>

        public virtual string GetExpressionSummary()

        {

            StringBuilder buf = new StringBuilder();



            buf.Append("seconds: ");

            buf.Append(GetExpressionSetSummary(seconds));

            buf.Append("\n");

            buf.Append("minutes: ");

            buf.Append(GetExpressionSetSummary(minutes));

            buf.Append("\n");

            buf.Append("hours: ");

            buf.Append(GetExpressionSetSummary(hours));

            buf.Append("\n");

            buf.Append("daysOfMonth: ");

            buf.Append(GetExpressionSetSummary(daysOfMonth));

            buf.Append("\n");

            buf.Append("months: ");

            buf.Append(GetExpressionSetSummary(months));

            buf.Append("\n");

            buf.Append("daysOfWeek: ");

            buf.Append(GetExpressionSetSummary(daysOfWeek));

            buf.Append("\n");

            buf.Append("lastdayOfWeek: ");

            buf.Append(lastdayOfWeek);

            buf.Append("\n");

            buf.Append("nearestWeekday: ");

            buf.Append(nearestWeekday);

            buf.Append("\n");

            buf.Append("NthDayOfWeek: ");

            buf.Append(nthdayOfWeek);

            buf.Append("\n");

            buf.Append("lastdayOfMonth: ");

            buf.Append(lastdayOfMonth);

            buf.Append("\n");

            buf.Append("calendardayOfWeek: ");

            buf.Append(calendardayOfWeek);

            buf.Append("\n");

            buf.Append("calendardayOfMonth: ");

            buf.Append(calendardayOfMonth);

            buf.Append("\n");

            buf.Append("years: ");

            buf.Append(GetExpressionSetSummary(years));

            buf.Append("\n");



            return buf.ToString();

        }



		/// <summary>

		/// Gets the expression set summary.

		/// </summary>

		/// <param name="data">The data.</param>

		/// <returns></returns>

        protected virtual string GetExpressionSetSummary(ISet data)

        {

            if (data.Contains(NoSpec))

            {

                return "?";

            }

            if (data.Contains(AllSpec))

            {

                return "*";

            }



            StringBuilder buf = new StringBuilder();



            bool first = true;

            foreach (int iVal in data)

            {

                string val = iVal.ToString(CultureInfo.InvariantCulture);

                if (!first)

                {

                    buf.Append(",");

                }

                buf.Append(val);

                first = false;

            }



            return buf.ToString();

        }



		/// <summary>

		/// Skips the white space.

		/// </summary>

		/// <param name="i">The i.</param>

		/// <param name="s">The s.</param>

		/// <returns></returns>

        protected virtual int SkipWhiteSpace(int i, string s)

        {

            for (; i < s.Length && (s[i] == ' ' || s[i] == '\t'); i++)

            {

                ;

            }



            return i;

        }



        /// <summary>

        /// Finds the next white space.

        /// </summary>

        /// <param name="i">The i.</param>

        /// <param name="s">The s.</param>

        /// <returns></returns>

        protected virtual int FindNextWhiteSpace(int i, string s)

        {

            for (; i < s.Length && (s[i] != ' ' || s[i] != '\t'); i++)

            {

                ;

            }



            return i;

        }



        /// <summary>

        /// Adds to set.

        /// </summary>

        /// <param name="val">The val.</param>

        /// <param name="end">The end.</param>

        /// <param name="incr">The incr.</param>

        /// <param name="type">The type.</param>

        protected virtual void AddToSet(int val, int end, int incr, int type)

        {

            TreeSet data = GetSet(type);



            if (type == Second || type == Minute)

            {

                if ((val < 0 || val > 59 || end > 59) && (val != AllSpecInt))

                {

                    throw new FormatException(

                        "Minute and Second values must be between 0 and 59");

                }

            }

            else if (type == Hour)

            {

                if ((val < 0 || val > 23 || end > 23) && (val != AllSpecInt))

                {

                    throw new FormatException(

                        "Hour values must be between 0 and 23");

                }

            }

            else if (type == DayOfMonth)

            {

                if ((val < 1 || val > 31 || end > 31) && (val != AllSpecInt)

                    && (val != NoSpecInt))

                {

                    throw new FormatException(

                        "Day of month values must be between 1 and 31");

                }

            }

            else if (type == Month)

            {

                if ((val < 1 || val > 12 || end > 12) && (val != AllSpecInt))

                {

                    throw new FormatException(

                        "Month values must be between 1 and 12");

                }

            }

            else if (type == DayOfWeek)

            {

                if ((val == 0 || val > 7 || end > 7) && (val != AllSpecInt)

                    && (val != NoSpecInt))

                {

                    throw new FormatException(

                        "Day-of-Week values must be between 1 and 7");

                }

            }



            if ((incr == 0 || incr == -1) && val != AllSpecInt)

            {

                if (val != -1)

                {

                    data.Add(val);

                }

                else

                {

                    data.Add(NoSpec);

                }

                return;

            }



            int startAt = val;

            int stopAt = end;



            if (val == AllSpecInt && incr <= 0)

            {

                incr = 1;

                data.Add(AllSpec); // put in a marker, but also fill values

            }



            if (type == Second || type == Minute)

            {

                if (stopAt == -1)

                {

                    stopAt = 59;

                }

                if (startAt == -1 || startAt == AllSpecInt)

                {

                    startAt = 0;

                }

            }

            else if (type == Hour)

            {

                if (stopAt == -1)

                {

                    stopAt = 23;

                }

                if (startAt == -1 || startAt == AllSpecInt)

                {

                    startAt = 0;

                }

            }

            else if (type == DayOfMonth)

            {

                if (stopAt == -1)

                {

                    stopAt = 31;

                }

                if (startAt == -1 || startAt == AllSpecInt)

                {

                    startAt = 1;

                }

            }

            else if (type == Month)

            {

                if (stopAt == -1)

                {

                    stopAt = 12;

                }

                if (startAt == -1 || startAt == AllSpecInt)

                {

                    startAt = 1;

                }

            }

            else if (type == DayOfWeek)

            {

                if (stopAt == -1)

                {

                    stopAt = 7;

                }

                if (startAt == -1 || startAt == AllSpecInt)

                {

                    startAt = 1;

                }

            }

            else if (type == Year)

            {

                if (stopAt == -1)

                {

                    stopAt = 2099;

                }

                if (startAt == -1 || startAt == AllSpecInt)

                {

                    startAt = 1970;

                }

            }



            // if the end of the range is before the start, then we need to overflow into 

            // the next day, month etc. This is done by adding the maximum amount for that 

            // type, and using modulus max to determine the value being added.

            int max = -1;

            if (stopAt < startAt)

            {

                switch (type)

                {

                    case Second: max = 60; break;

                    case Minute: max = 60; break;

                    case Hour: max = 24; break;

                    case Month: max = 12; break;

                    case DayOfWeek: max = 7; break;

                    case DayOfMonth: max = 31; break;

                    case Year: throw new ArgumentException("Start year must be less than stop year");

                    default: throw new ArgumentException("Unexpected type encountered");

                }

                stopAt += max;

            }



            for (int i = startAt; i <= stopAt; i += incr)

            {

                if (max == -1)

                {

                    // ie: there's no max to overflow over

                    data.Add(i);

                }

                else

                {

                    // take the modulus to get the real value

                    int i2 = i % max;



                    // 1-indexed ranges should not include 0, and should include their max

                    if (i2 == 0 && (type == Month || type == DayOfWeek || type == DayOfMonth))

                    {

                        i2 = max;

                    }



                    data.Add(i2);

                }

            }

        }



		/// <summary>

		/// Gets the set of given type.

		/// </summary>

		/// <param name="type">The type of set to get.</param>

		/// <returns></returns>

        protected virtual TreeSet GetSet(int type)

        {

            switch (type)

            {

                case Second:

                    return seconds;

                case Minute:

                    return minutes;

                case Hour:

                    return hours;

                case DayOfMonth:

                    return daysOfMonth;

                case Month:

                    return months;

                case DayOfWeek:

                    return daysOfWeek;…

Large files files are truncated, but you can click here to view the full file