/// <summary>
 /// Returns an union of two values.
 /// </summary>
 public static DayOfMonth operator |(DayOfMonth first, DayOfMonth second)
 {
     DayOfMonth monthDays = new DayOfMonth(first._includeValue, first._excludeValue);
     monthDays._includeValue |= second._includeValue;
     monthDays._excludeValue |= second._excludeValue;
     return monthDays;
 }
        /// <summary>
        /// Gets all of the defined values.
        /// </summary>
        public static DayOfMonth[] GetValues()
        {
            Type type = typeof(DayOfMonth);
            FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
            ArrayList monthDays = new ArrayList();

            for (int i = 0; i < fields.Length; i++)
            {
                FieldInfo field = fields[i];

                if (field.FieldType == typeof(DayOfMonth))
                {
                    monthDays.Add(field.GetValue(null));
                }
            }

            DayOfMonth[] returnArray = new DayOfMonth[monthDays.Count];
            monthDays.CopyTo(returnArray, 0);
            return returnArray;
        }
        /// <summary>
        /// Parses the specified string value.
        /// </summary>
        public static DayOfMonth Parse(string value)
        {
            DayOfMonth monthDays = new DayOfMonth(0);

            if (value != null && value.Length != 0)
            {
                MatchCollection matches = _parser.Matches(value);

                if (matches.Count != 0)
                {
                    int startIndex = 0;
                    string lastMatch = null;

                    foreach (Match match in matches)
                    {
                        string innerString = value.Substring(startIndex, match.Index - startIndex);
                        monthDays.Append(lastMatch, innerString);
                        lastMatch = match.Value;
                        startIndex = match.Index + 1;
                    }

                    if (startIndex != value.Length)
                    {
                        string innerString = value.Substring(startIndex, value.Length - startIndex);
                        monthDays.Append(lastMatch, innerString);
                    }
                }
                else
                {
                    string valueUpper = value.ToUpper();

                    switch (valueUpper)
                    {
                        case "EMPTY":
                            {
                                monthDays = Empty;
                                break;
                            }

                        case "ALLDAYS":
                            {
                                monthDays = AllDays;
                                break;
                            }

                        case "ALLWEEKDAYS":
                            {
                                monthDays = AllWeekdays;
                                break;
                            }

                        case "ALLWEEKENDS":
                            {
                                monthDays = AllWeekends;
                                break;
                            }

                        case "ALLSUNDAYS":
                            {
                                monthDays = AllSundays;
                                break;
                            }

                        case "ALLMONDAYS":
                            {
                                monthDays = AllMondays;
                                break;
                            }

                        case "ALLTUESDAYS":
                            {
                                monthDays = AllTuesdays;
                                break;
                            }

                        case "ALLWEDNESDAYS":
                            {
                                monthDays = AllWednesdays;
                                break;
                            }

                        case "ALLTHURSDAYS":
                            {
                                monthDays = AllThursdays;
                                break;
                            }

                        case "ALLFRIDAYS":
                            {
                                monthDays = AllFridays;
                                break;
                            }

                        case "ALLSATURDAYS":
                            {
                                monthDays = AllSaturdays;
                                break;
                            }

                        case "FIRSTDAY":
                            {
                                monthDays = FirstDay;
                                break;
                            }

                        case "FIRSTFRIDAY":
                            {
                                monthDays = FirstFriday;
                                break;
                            }

                        case "FIRSTMONDAY":
                            {
                                monthDays = FirstMonday;
                                break;
                            }

                        case "FIRSTSATURDAY":
                            {
                                monthDays = FirstSaturday;
                                break;
                            }

                        case "FIRSTSUNDAY":
                            {
                                monthDays = FirstSunday;
                                break;
                            }

                        case "FIRSTTHURSDAY":
                            {
                                monthDays = FirstThursday;
                                break;
                            }

                        case "FIRSTTUESDAY":
                            {
                                monthDays = FirstTuesday;
                                break;
                            }

                        case "FIRSTWEDNESDAY":
                            {
                                monthDays = FirstWednesday;
                                break;
                            }

                        case "FIRSTWEEKDAY":
                            {
                                monthDays = FirstWeekday;
                                break;
                            }

                        case "FIRSTWEEKEND":
                            {
                                monthDays = FirstWeekend;
                                break;
                            }

                        case "FOURTHFRIDAY":
                            {
                                monthDays = FourthFriday;
                                break;
                            }

                        case "FOURTHMONDAY":
                            {
                                monthDays = FourthMonday;
                                break;
                            }

                        case "FOURTHSATURDAY":
                            {
                                monthDays = FourthSaturday;
                                break;
                            }

                        case "FOURTHSUNDAY":
                            {
                                monthDays = FourthSunday;
                                break;
                            }

                        case "FOURTHTHURSDAY":
                            {
                                monthDays = FourthThursday;
                                break;
                            }

                        case "FOURTHTUESDAY":
                            {
                                monthDays = FourthTuesday;
                                break;
                            }

                        case "FOURTHWEDNESDAY":
                            {
                                monthDays = FourthWednesday;
                                break;
                            }

                        case "LASTDAY":
                            {
                                monthDays = LastDay;
                                break;
                            }

                        case "LASTFRIDAY":
                            {
                                monthDays = LastFriday;
                                break;
                            }

                        case "LASTMONDAY":
                            {
                                monthDays = LastMonday;
                                break;
                            }

                        case "LASTSATURDAY":
                            {
                                monthDays = LastSaturday;
                                break;
                            }

                        case "LASTSUNDAY":
                            {
                                monthDays = LastSunday;
                                break;
                            }

                        case "LASTTHURSDAY":
                            {
                                monthDays = LastThursday;
                                break;
                            }

                        case "LASTTUESDAY":
                            {
                                monthDays = LastTuesday;
                                break;
                            }

                        case "LASTWEDNESDAY":
                            {
                                monthDays = LastWednesday;
                                break;
                            }

                        case "LASTWEEKDAY":
                            {
                                monthDays = LastWeekday;
                                break;
                            }

                        case "LASTWEEKEND":
                            {
                                monthDays = LastWeekend;
                                break;
                            }

                        case "SECONDFRIDAY":
                            {
                                monthDays = SecondFriday;
                                break;
                            }

                        case "SECONDMONDAY":
                            {
                                monthDays = SecondMonday;
                                break;
                            }

                        case "SECONDSATURDAY":
                            {
                                monthDays = SecondSaturday;
                                break;
                            }

                        case "SECONDSUNDAY":
                            {
                                monthDays = SecondSunday;
                                break;
                            }

                        case "SECONDTHURSDAY":
                            {
                                monthDays = SecondThursday;
                                break;
                            }

                        case "SECONDTUESDAY":
                            {
                                monthDays = SecondTuesday;
                                break;
                            }

                        case "SECONDWEDNESDAY":
                            {
                                monthDays = SecondWednesday;
                                break;
                            }

                        case "THIRDFRIDAY":
                            {
                                monthDays = ThirdFriday;
                                break;
                            }

                        case "THIRDMONDAY":
                            {
                                monthDays = ThirdMonday;
                                break;
                            }

                        case "THIRDSATURDAY":
                            {
                                monthDays = ThirdSaturday;
                                break;
                            }

                        case "THIRDSUNDAY":
                            {
                                monthDays = ThirdSunday;
                                break;
                            }

                        case "THIRDTHURSDAY":
                            {
                                monthDays = ThirdThursday;
                                break;
                            }

                        case "THIRDTUESDAY":
                            {
                                monthDays = ThirdTuesday;
                                break;
                            }

                        case "THIRDWEDNESDAY":
                            {
                                monthDays = ThirdWednesday;
                                break;
                            }

                        default:
                            {
                                if (IsNumeric(value))
                                {
                                    monthDays = Absolute(byte.Parse(value));
                                }
                                else if (valueUpper.EndsWith("ST") || valueUpper.EndsWith("RD") ||
                                         valueUpper.EndsWith("TH") || valueUpper.EndsWith("ND"))
                                {
                                    value = value.Substring(0, value.Length - 2);
                                    monthDays = Absolute(byte.Parse(value));
                                }

                                break;
                            }
                    }
                }
            }

            return monthDays;
        }
 /// <summary>
 /// Creates an absolute day-of-month. Used to specify
 /// the 3rd day of the month, the 5th day of the month,
 /// the 15th day of the month, etc.
 /// </summary>
 public static DayOfMonth Absolute(byte day)
 {
     DayOfMonth dayOfMonth = new DayOfMonth(ABSOLUTE_DAY);
     dayOfMonth._includeAbsolute = (long)Math.Pow(2, day - 1);
     return dayOfMonth;
 }