示例#1
0
        static void InlineAssertInvariants(CSVersion v)
        {
#if DEBUG
            if (!_alreadyInCheck && v.IsValid)
            {
                _alreadyInCheck = true;
                try
                {
                    if (v.IsLongForm)
                    {
                        Debug.Assert(v.NormalizedText == ComputeLongFormVersion(v.Major, v.Minor, v.Patch, v.PrereleaseNameIdx, v.PrereleaseNumber, v.PrereleasePatch, v.BuildMetaData));
                    }
                    else
                    {
                        Debug.Assert(v.NormalizedText == ComputeShortFormVersion(v.Major, v.Minor, v.Patch, v.PrereleaseNameIdx, v.PrereleaseNumber, v.PrereleasePatch, v.BuildMetaData));
                    }
                    //// Systematically checks that a valid CSVersion can be parsed back in Long or Short form.
                    Debug.Assert(SVersion.TryParse(v.ToString(CSVersionFormat.Normalized)).Equals(v.ToNormalizedForm()));
                    Debug.Assert(SVersion.TryParse(v.ToString(CSVersionFormat.LongForm)).Equals(v.ToLongForm()));
                }
                finally
                {
                    _alreadyInCheck = false;
                }
            }
#endif
        }
示例#2
0
        static SVersion DoCreate(string?parsedText, int major, int minor, int patch, string prerelease, string buildMetaData, bool handleCSVersion, bool checkBuildMetaDataSyntax)
        {
            Debug.Assert(prerelease != null && buildMetaData != null);
            if (major < 0 || minor < 0 || patch < 0)
            {
                return(new SVersion("Major, minor and patch must positive or 0.", parsedText));
            }

            if (buildMetaData.Length > 0 && checkBuildMetaDataSyntax)
            {
                var error = ValidateDottedIdentifiers(buildMetaData, "build metadata");
                if (error != null)
                {
                    return(new SVersion(error, parsedText));
                }
            }
            // Try CSVersion first.
            CSVersion?c = CSVersion.FromSVersion(parsedText, major, minor, patch, prerelease, buildMetaData);

            if (handleCSVersion && c != null)
            {
                return(c);
            }
            // If it is not a CSVersion, validate the prerelease.
            // A Stable is not necessarily a CSVersion (too big Major/Minor/Patch).
            if (c == null && prerelease.Length > 0)
            {
                var error = ValidateDottedIdentifiers(prerelease, "pre-release");
                if (error != null)
                {
                    return(new SVersion(error, parsedText));
                }
            }
            return(new SVersion(parsedText, major, minor, patch, prerelease, buildMetaData, c));
        }
 /// <summary>
 /// Relies only on <see cref="OrderedVersion"/>.
 /// </summary>
 /// <param name="other">Other release tag (can be null).</param>
 /// <returns>A signed number indicating the relative values of this instance and <paramref name="other"/>.</returns>
 public int CompareTo(CSVersion other)
 {
     if (other == null)
     {
         return(1);
     }
     return(_orderedVersion.Number.CompareTo(other._orderedVersion.Number));
 }
 /// <summary>
 /// Versions are equal if their <see cref="OrderedVersion"/> are equals.
 /// No other members are used for equality and comparison.
 /// </summary>
 /// <param name="other">Other version.</param>
 /// <returns>True if they have the same OrderedVersion.</returns>
 public bool Equals(CSVersion other)
 {
     if (other == null)
     {
         return(false);
     }
     return(_orderedVersion.Number == other._orderedVersion.Number);
 }
示例#5
0
 CSVersion(CSVersion other, string?buildMetaData)
     : base(other, buildMetaData ?? String.Empty, null)
 {
     PrereleaseNameIdx = other.PrereleaseNameIdx;
     PrereleaseNumber  = other.PrereleaseNumber;
     PrereleasePatch   = other.PrereleasePatch;
     _orderedVersion   = other._orderedVersion;
     IsLongForm        = other.IsLongForm;
     InlineAssertInvariants(this);
 }
        /// <summary>
        /// Standard TryParse pattern that returns a boolean rather than the resulting <see cref="CSVersion"/>.
        /// See <see cref="TryParse(string,bool)"/>.
        /// </summary>
        /// <param name="s">String to parse.</param>
        /// <param name="v">Resulting version.</param>
        /// <param name="checkBuildMetaDataSyntax">False to opt-out of strict <see cref="SVersion.BuildMetaData"/> compliance.</param>
        /// <returns>True on success, false otherwise.</returns>
        public static bool TryParse(string s, out CSVersion v, bool checkBuildMetaDataSyntax = true)
        {
            v = null;
            SVersion sv = SVersion.TryParse(s, true, checkBuildMetaDataSyntax);

            if (!sv.IsValid)
            {
                return(false);
            }
            v = sv as CSVersion;
            return(v != null);
        }
        /// <summary>
        /// Parses the specified string to a constrained semantic version and throws an <see cref="ArgumentException"/>
        /// it the resulting <see cref="SVersion"/> is not a <see cref="CSVersion"/> or <see cref="SVersion.IsValid"/> is false.
        /// </summary>
        /// <param name="s">The string to parse.</param>
        /// <param name="checkBuildMetaDataSyntax">False to opt-out of strict <see cref="SVersion.BuildMetaData"/> compliance.</param>
        /// <returns>The CSVersion object.</returns>
        public static CSVersion Parse(string s, bool checkBuildMetaDataSyntax = true)
        {
            SVersion sv = SVersion.TryParse(s, true, checkBuildMetaDataSyntax);

            if (!sv.IsValid)
            {
                throw new ArgumentException(sv.ErrorMessage, nameof(s));
            }
            CSVersion v = sv as CSVersion;

            if (v == null)
            {
                throw new ArgumentException("Not a CSVersion.", nameof(s));
            }
            return(v);
        }
示例#8
0
 /// <summary>
 /// Protected straight constructor for valid versions.
 /// No checks are done here.
 /// </summary>
 /// <param name="parsedText">The parsed text. Null if not parsed.</param>
 /// <param name="major">The major.</param>
 /// <param name="minor">The minor.</param>
 /// <param name="patch">The patch.</param>
 /// <param name="prerelease">The prerelease. Can be null (normalized to the empty string).</param>
 /// <param name="buildMetaData">The build meta data. Can be null (normalized to the empty string).</param>
 /// <param name="csVersion">Companion CSVersion.</param>
 protected SVersion(string parsedText, int major, int minor, int patch, string prerelease, string buildMetaData, CSVersion csVersion)
 {
     if (buildMetaData == null)
     {
         buildMetaData = String.Empty;
     }
     if (buildMetaData.Length > 0 && buildMetaData[0] == '+')
     {
         throw new ArgumentException("Must not start with '+'.", nameof(buildMetaData));
     }
     _csVersion     = csVersion ?? (this as CSVersion);
     Major          = major;
     Minor          = minor;
     Patch          = patch;
     Prerelease     = prerelease ?? String.Empty;
     BuildMetaData  = buildMetaData;
     ParsedText     = parsedText;
     NormalizedText = ComputeNormalizedText(major, minor, patch, prerelease);
     NormalizedTextWithBuildMetaData = buildMetaData.Length > 0 ? NormalizedText + '+' + buildMetaData : NormalizedText;
 }
示例#9
0
 /// <summary>
 /// Protected copy constructor with <see cref="BuildMetaData"/>.
 /// </summary>
 /// <param name="other">Origin version.</param>
 /// <param name="buildMetaData">New BuildMetaData. Must not be null.</param>
 /// <param name="csVersion">Companion CSVersion.</param>
 protected SVersion(SVersion other, string buildMetaData, CSVersion csVersion)
 {
     if (other == null)
     {
         throw new ArgumentNullException(nameof(other));
     }
     if (buildMetaData == null)
     {
         throw new ArgumentNullException(nameof(buildMetaData));
     }
     if (!other.IsValid)
     {
         throw new InvalidOperationException("Version must be valid.");
     }
     _csVersion     = csVersion ?? (this as CSVersion);
     Major          = other.Major;
     Minor          = other.Minor;
     Patch          = other.Patch;
     Prerelease     = other.Prerelease;
     BuildMetaData  = buildMetaData;
     NormalizedText = ComputeNormalizedText(Major, Minor, Patch, Prerelease);
     NormalizedTextWithBuildMetaData = buildMetaData.Length > 0 ? NormalizedText + '+' + buildMetaData : NormalizedText;
 }
        static IReadOnlyList <CSVersion> BuildFirstPossibleVersions()
        {
            var  versions = new CSVersion[3 * 9];
            long v        = 1L;
            int  i        = 0;

            while (i < 3 * 9)
            {
                versions[i++] = Create(v);
                if ((i % 18) == 0)
                {
                    v += MulMajor - MulMinor - MulPatch + 1;
                }
                else if ((i % 9) == 0)
                {
                    v += MulMinor - MulPatch + 1;
                }
                else
                {
                    v += MulName;
                }
            }
            return(versions);
        }