Beispiel #1
0
 /// <summary>
 /// Gets the <see cref="BuildVersionIncrement.Incrementors.BaseIncrementor"/> representing the specified old style enum.
 /// </summary>
 /// <value>The old style enum.</value>
 public BaseIncrementor this[OLD_IncrementStyle oldStyle]
 {
     get
     {
         return(this[oldStyle.ToString()]);
     }
 }
Beispiel #2
0
 /// <summary>
 /// Initializes this instance based on the old increment enum styles.
 /// </summary>
 /// <param name="major">The major style.</param>
 /// <param name="minor">The minor style.</param>
 /// <param name="build">The build style.</param>
 /// <param name="revision">The revision style.</param>
 internal void FromOldIncrementStyle(OLD_IncrementStyle major, OLD_IncrementStyle minor, OLD_IncrementStyle build, OLD_IncrementStyle revision)
 {
     Major    = BuildVersionIncrementor.Instance.Incrementors[major];
     Minor    = BuildVersionIncrementor.Instance.Incrementors[minor];
     Build    = BuildVersionIncrementor.Instance.Incrementors[build];
     Revision = BuildVersionIncrementor.Instance.Incrementors[revision];
 }
        internal void FromGlobalVariable(string value)
        {
            if (!string.IsNullOrEmpty(value))
            {
                if (value.Contains("."))
                {
                    string[] array = value.Split(".".ToCharArray());
                    if (array.Length != 4)
                    {
                        throw new ApplicationException("Invalid versioning style \"" + value + "\".");
                    }
                    this.Major    = BuildVersionIncrementor.Instance.Incrementors[array[0]];
                    this.Minor    = BuildVersionIncrementor.Instance.Incrementors[array[1]];
                    this.Build    = BuildVersionIncrementor.Instance.Incrementors[array[2]];
                    this.Revision = BuildVersionIncrementor.Instance.Incrementors[array[3]];
                }
                else
                {
                    OLD_BuildVersioningStyleType oLD_BuildVersioningStyleType = (OLD_BuildVersioningStyleType)Enum.Parse(typeof(OLD_BuildVersioningStyleType), value);
                    OLD_IncrementStyle           major    = OLD_IncrementStyle.None;
                    OLD_IncrementStyle           minor    = OLD_IncrementStyle.None;
                    OLD_IncrementStyle           revision = OLD_IncrementStyle.None;
                    OLD_IncrementStyle           build;
                    switch (oLD_BuildVersioningStyleType)
                    {
                    case OLD_BuildVersioningStyleType.DeltaBaseDate:
                        build    = OLD_IncrementStyle.DeltaBaseDate;
                        revision = OLD_IncrementStyle.TimeStamp;
                        break;

                    case OLD_BuildVersioningStyleType.YearDayOfYear_Timestamp:
                        build    = OLD_IncrementStyle.YearDayOfYear;
                        revision = OLD_IncrementStyle.TimeStamp;
                        break;

                    case OLD_BuildVersioningStyleType.DeltaBaseYear:
                        build    = OLD_IncrementStyle.DeltaBaseYearDayOfYear;
                        revision = OLD_IncrementStyle.TimeStamp;
                        break;

                    case OLD_BuildVersioningStyleType.YearDayOfYear_AutoIncrement:
                        build    = OLD_IncrementStyle.YearDayOfYear;
                        revision = OLD_IncrementStyle.Increment;
                        break;

                    case OLD_BuildVersioningStyleType.AutoIncrementBuildVersion:
                        build = OLD_IncrementStyle.Increment;
                        break;

                    default:
                        throw new ApplicationException("Unknown (old) versioning type: " + oLD_BuildVersioningStyleType.ToString());
                    }
                    this.FromOldIncrementStyle(major, minor, build, revision);
                }
            }
            else
            {
                this.Major = (this.Minor = (this.Build = (this.Revision = null)));
            }
        }
 public BaseIncrementor this[OLD_IncrementStyle oldStyle]
 {
     get
     {
         return this[oldStyle.ToString()];
     }
 }
 public virtual string Increment(int current, OLD_IncrementStyle incrementStyle)
 {
     string arg = this.BuildStartDate.DayOfYear.ToString("000");
     int num = this.BuildStartDate.Year - this.ProjectStartDate.Year;
     string text = this.BuildStartDate.ToString("yy");
     if (current < 0)
     {
         current = 0;
     }
     string result;
     switch (incrementStyle)
     {
     case OLD_IncrementStyle.None:
         result = current.ToString();
         break;
     case OLD_IncrementStyle.DayStamp:
         result = this.BuildStartDate.Day.ToString();
         break;
     case OLD_IncrementStyle.DeltaBaseDate:
     {
         DateSpan dateDifference = DateSpan.GetDateDifference(this.BuildStartDate, this.ProjectStartDate);
         result = string.Format("{0}{1:00}", dateDifference.Years * 12 + dateDifference.Months, dateDifference.Days);
         break;
     }
     case OLD_IncrementStyle.DeltaBaseYearDayOfYear:
         result = string.Format("{0}{1:000}", num, arg);
         break;
     case OLD_IncrementStyle.DeltaBaseYear:
         result = num.ToString();
         break;
     case OLD_IncrementStyle.Increment:
         result = (current + 1).ToString();
         break;
     case OLD_IncrementStyle.MonthStamp:
         result = this.BuildStartDate.Month.ToString();
         break;
     case OLD_IncrementStyle.TimeStamp:
         result = string.Format("{0:00}{1:00}", this.BuildStartDate.Hour, this.BuildStartDate.Minute);
         break;
     case OLD_IncrementStyle.YearStamp:
         result = this.BuildStartDate.Year.ToString();
         break;
     case OLD_IncrementStyle.YearDayOfYear:
         result = string.Format("{0}{1:000}", text, arg);
         break;
     case OLD_IncrementStyle.YearDecadeStamp:
         result = text;
         break;
     case OLD_IncrementStyle.MonthAndDayStamp:
         result = string.Format("{0:00}{1:00}", this.BuildStartDate.Month, this.BuildStartDate.Day);
         break;
     case OLD_IncrementStyle.DeltaBaseDateInDays:
         result = ((int)this.BuildStartDate.Subtract(this.ProjectStartDate).TotalDays).ToString();
         break;
     default:
         throw new ApplicationException("Unknown increment style: " + incrementStyle.ToString());
     }
     return result;
 }
 internal void FromOldIncrementStyle(OLD_IncrementStyle major, OLD_IncrementStyle minor, OLD_IncrementStyle build, OLD_IncrementStyle revision)
 {
     this.Major = BuildVersionIncrementor.Instance.Incrementors[major];
     this.Minor = BuildVersionIncrementor.Instance.Incrementors[minor];
     this.Build = BuildVersionIncrementor.Instance.Incrementors[build];
     this.Revision = BuildVersionIncrementor.Instance.Incrementors[revision];
 }
Beispiel #7
0
        /// <summary>
        /// Initializes this instances based on a global variable value.
        /// </summary>
        /// <param name="value">The value.</param>
        internal void FromGlobalVariable(string value)
        {
            if (!string.IsNullOrEmpty(value))
            {
                if (value.Contains("."))
                {
                    // Assuming new enum

                    string[] styles = value.Split(".".ToCharArray());

                    if (styles.Length == 4)
                    {
                        Major    = BuildVersionIncrementor.Instance.Incrementors[styles[0]];
                        Minor    = BuildVersionIncrementor.Instance.Incrementors[styles[1]];
                        Build    = BuildVersionIncrementor.Instance.Incrementors[styles[2]];
                        Revision = BuildVersionIncrementor.Instance.Incrementors[styles[3]];

                        /*OLD_IncrementStyle major = (OLD_IncrementStyle)Enum.Parse(typeof(OLD_IncrementStyle), styles[0]);
                         * OLD_IncrementStyle minor = (OLD_IncrementStyle)Enum.Parse(typeof(OLD_IncrementStyle), styles[1]);
                         * OLD_IncrementStyle build = (OLD_IncrementStyle)Enum.Parse(typeof(OLD_IncrementStyle), styles[2]);
                         * OLD_IncrementStyle revision = (OLD_IncrementStyle)Enum.Parse(typeof(OLD_IncrementStyle), styles[3]);
                         *
                         * FromOldIncrementStyle(major, minor, build, revision);*/
                    }
                    else
                    {
                        throw (new ApplicationException("Invalid versioning style \"" + value + "\"."));
                    }
                }
                else
                {
                    // Old enum

                    OLD_BuildVersioningStyleType oldStyle = (OLD_BuildVersioningStyleType)Enum.Parse(typeof(OLD_BuildVersioningStyleType), value);

                    OLD_IncrementStyle major    = OLD_IncrementStyle.None;
                    OLD_IncrementStyle minor    = OLD_IncrementStyle.None;
                    OLD_IncrementStyle build    = OLD_IncrementStyle.None;
                    OLD_IncrementStyle revision = OLD_IncrementStyle.None;

                    switch (oldStyle)
                    {
                    case OLD_BuildVersioningStyleType.AutoIncrementBuildVersion:
                        build = OLD_IncrementStyle.Increment;
                        break;

                    case OLD_BuildVersioningStyleType.DeltaBaseDate:
                        build    = OLD_IncrementStyle.DeltaBaseDate;
                        revision = OLD_IncrementStyle.TimeStamp;
                        break;

                    case OLD_BuildVersioningStyleType.DeltaBaseYear:
                        build    = OLD_IncrementStyle.DeltaBaseYearDayOfYear;
                        revision = OLD_IncrementStyle.TimeStamp;
                        break;

                    case OLD_BuildVersioningStyleType.YearDayOfYear_AutoIncrement:
                        build    = OLD_IncrementStyle.YearDayOfYear;
                        revision = OLD_IncrementStyle.Increment;
                        break;

                    case OLD_BuildVersioningStyleType.YearDayOfYear_Timestamp:
                        build    = OLD_IncrementStyle.YearDayOfYear;
                        revision = OLD_IncrementStyle.TimeStamp;
                        break;

                    default:
                        throw (new ApplicationException("Unknown (old) versioning type: " + oldStyle.ToString()));
                    }

                    FromOldIncrementStyle(major, minor, build, revision);
                }
            }
            else
            {
                Major = Minor = Build = Revision = null;
            }
        }
Beispiel #8
0
        /// <summary>
        /// Increments the specified version number.
        /// </summary>
        /// <param name="current">The current number.</param>
        /// <param name="incrementStyle">The increment style.</param>
        /// <returns>The incremented version number.</returns>
        public virtual string Increment(int current, OLD_IncrementStyle incrementStyle)
        {
            string dayOfyear  = BuildStartDate.DayOfYear.ToString("000");
            int    deltaYears = BuildStartDate.Year - ProjectStartDate.Year;
            string yearDecade = BuildStartDate.ToString("yy");

            if (current < 0)
            {
                current = 0;
            }

            switch (incrementStyle)
            {
            case OLD_IncrementStyle.None:
                return(current.ToString());

            case OLD_IncrementStyle.Increment:
                return((current + 1).ToString());

            case OLD_IncrementStyle.TimeStamp:
                return(string.Format("{0:00}{1:00}", BuildStartDate.Hour, BuildStartDate.Minute));

            /*case IncrementStyle.DateStamp:
             *
             * This will not work; version numbers are 64 bit (4x16) so the maximum a counter can hold is 65534. Using the code below will
             * result in a "The version specified ‘x.x.x.x′ is invalid".
             *
             * return Int32.Parse(string.Format("{0:0000}{1:00}{2:00}", BuildStartDate.Year, BuildStartDate.Month, BuildStartDate.Day));
             *
             */

            case OLD_IncrementStyle.YearStamp:
                return(BuildStartDate.Year.ToString());

            case OLD_IncrementStyle.DeltaBaseDate:
                /*TimeSpan ts = BuildStartDate.Subtract(ProjectStartDate);
                 * DateTime dt = DateTime.MinValue + ts;
                 * return Int32.Parse(string.Format("{0}{1:00}", dt.Year * 12 + dt.Month, dt.Day));*/

                // Fixed Yogesh Jagota's increment scheme
                DateSpan ds = DateSpan.GetDateDifference(BuildStartDate, ProjectStartDate);
                return(string.Format("{0}{1:00}", (ds.Years * 12) + ds.Months, ds.Days));

            case OLD_IncrementStyle.DeltaBaseDateInDays:
                TimeSpan ts = BuildStartDate.Subtract(ProjectStartDate);
                return(((int)ts.TotalDays).ToString());

            case OLD_IncrementStyle.YearDayOfYear:
                return(string.Format("{0}{1:000}", yearDecade, dayOfyear));

            case OLD_IncrementStyle.DeltaBaseYearDayOfYear:
                return(string.Format("{0}{1:000}", deltaYears, dayOfyear));

            case OLD_IncrementStyle.DeltaBaseYear:
                return(deltaYears.ToString());

            case OLD_IncrementStyle.YearDecadeStamp:
                return(yearDecade);

            case OLD_IncrementStyle.MonthStamp:
                return(BuildStartDate.Month.ToString());

            case OLD_IncrementStyle.DayStamp:
                return(BuildStartDate.Day.ToString());

            case OLD_IncrementStyle.MonthAndDayStamp:
                return(string.Format("{0:00}{1:00}", BuildStartDate.Month, BuildStartDate.Day));

            default:
                throw (new ApplicationException("Unknown increment style: " + incrementStyle.ToString()));
            }
        }
        public virtual string Increment(int current, OLD_IncrementStyle incrementStyle)
        {
            string arg  = this.BuildStartDate.DayOfYear.ToString("000");
            int    num  = this.BuildStartDate.Year - this.ProjectStartDate.Year;
            string text = this.BuildStartDate.ToString("yy");

            if (current < 0)
            {
                current = 0;
            }
            string result;

            switch (incrementStyle)
            {
            case OLD_IncrementStyle.None:
                result = current.ToString();
                break;

            case OLD_IncrementStyle.DayStamp:
                result = this.BuildStartDate.Day.ToString();
                break;

            case OLD_IncrementStyle.DeltaBaseDate:
            {
                DateSpan dateDifference = DateSpan.GetDateDifference(this.BuildStartDate, this.ProjectStartDate);
                result = string.Format("{0}{1:00}", dateDifference.Years * 12 + dateDifference.Months, dateDifference.Days);
                break;
            }

            case OLD_IncrementStyle.DeltaBaseYearDayOfYear:
                result = string.Format("{0}{1:000}", num, arg);
                break;

            case OLD_IncrementStyle.DeltaBaseYear:
                result = num.ToString();
                break;

            case OLD_IncrementStyle.Increment:
                result = (current + 1).ToString();
                break;

            case OLD_IncrementStyle.MonthStamp:
                result = this.BuildStartDate.Month.ToString();
                break;

            case OLD_IncrementStyle.TimeStamp:
                result = string.Format("{0:00}{1:00}", this.BuildStartDate.Hour, this.BuildStartDate.Minute);
                break;

            case OLD_IncrementStyle.YearStamp:
                result = this.BuildStartDate.Year.ToString();
                break;

            case OLD_IncrementStyle.YearDayOfYear:
                result = string.Format("{0}{1:000}", text, arg);
                break;

            case OLD_IncrementStyle.YearDecadeStamp:
                result = text;
                break;

            case OLD_IncrementStyle.MonthAndDayStamp:
                result = string.Format("{0:00}{1:00}", this.BuildStartDate.Month, this.BuildStartDate.Day);
                break;

            case OLD_IncrementStyle.DeltaBaseDateInDays:
                result = ((int)this.BuildStartDate.Subtract(this.ProjectStartDate).TotalDays).ToString();
                break;

            default:
                throw new ApplicationException("Unknown increment style: " + incrementStyle.ToString());
            }
            return(result);
        }