< Summary

Class:GDX.Developer.SemanticVersion
Assembly:GDX
File(s):D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Developer/SemanticVersion.cs
Covered lines:86
Uncovered lines:0
Coverable lines:86
Total lines:243
Line coverage:100% (86 of 86)
Covered branches:0
Total branches:0
Covered methods:11
Total methods:11
Method coverage:100% (11 of 11)

Coverage History

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SemanticVersion()0%110100%
SemanticVersion(...)0%660100%
operator>(...)0%660100%
operator>=(...)0%990100%
operator<=(...)0%990100%
operator<(...)0%660100%
operator==(...)0%330100%
operator!=(...)0%330100%
Equals(...)0%220100%
GetHashCode()0%110100%
Equals(...)0%330100%

File(s)

D:/BuildAgent/work/GDX-Documentation/Projects/GDX_Development/Packages/com.dotbunny.gdx/GDX/Developer/SemanticVersion.cs

#LineLine coverage
 1// Copyright (c) 2020-2022 dotBunny Inc.
 2// dotBunny licenses this file to you under the BSL-1.0 license.
 3// See the LICENSE file in the project root for more information.
 4
 5using System.Runtime.CompilerServices;
 6
 7namespace GDX.Developer
 8{
 9    /// <summary>
 10    ///     A Semantic Versioning structure.
 11    /// </summary>
 12    /// <remarks>https://semver.org/</remarks>
 13    public readonly struct SemanticVersion
 14    {
 15        /// <summary>
 16        ///     An array of <see cref="char" /> used to split versions.
 17        /// </summary>
 118        static readonly char[] k_VersionIndicators = {'.', ',', '_', 'f'};
 19
 20        /// <summary>
 21        ///     Major Version.
 22        /// </summary>
 23        /// <remarks>Is incremented when you make incompatible API changes.</remarks>
 24        public readonly int Major;
 25
 26        /// <summary>
 27        ///     Minor Version.
 28        /// </summary>
 29        /// <remarks>Is incremented when you add functionality in a backwards-compatible manner.</remarks>
 30        public readonly int Minor;
 31
 32        /// <summary>
 33        ///     Patch Version
 34        /// </summary>
 35        /// <remarks>Is incremented when you make backwards-compatible fixes.</remarks>
 36        public readonly int Patch;
 37
 38        /// <summary>
 39        ///     Create a <see cref="SemanticVersion" /> based on a formatted <see cref="string" />.
 40        /// </summary>
 41        /// <param name="version">A formatted version semantic version string (2020.1.0).</param>
 42        public SemanticVersion(string version)
 4943        {
 4944            string[] split = version.Split(k_VersionIndicators);
 4945            switch (split.Length)
 46            {
 47                case 4:
 648                    int.TryParse(split[0], out Major);
 649                    int.TryParse(split[1], out Minor);
 650                    int.TryParse(split[2], out Patch);
 651                    break;
 52                case 3:
 4053                    int.TryParse(split[0], out Major);
 4054                    int.TryParse(split[1], out Minor);
 4055                    int.TryParse(split[2], out Patch);
 4056                    break;
 57                case 2:
 158                    int.TryParse(split[0], out Major);
 159                    int.TryParse(split[1], out Minor);
 160                    Patch = 0;
 161                    break;
 62                case 1:
 163                    int.TryParse(split[0], out Major);
 164                    Minor = 0;
 165                    Patch = 0;
 166                    break;
 67                default:
 168                    Major = 0;
 169                    Minor = 0;
 170                    Patch = 0;
 171                    break;
 72            }
 4973        }
 74
 75        /// <summary>
 76        ///     Determine if <see cref="SemanticVersion" /> is greater than another <see cref="SemanticVersion" />.
 77        /// </summary>
 78        /// <param name="lhs">Left-hand side <see cref="SemanticVersion" />.</param>
 79        /// <param name="rhs">Right-hand side <see cref="SemanticVersion" />.</param>
 80        /// <returns>Returns the result of a GREATER THAN operation on two <see cref="SemanticVersion" /> values.</retur
 81        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 82        public static bool operator >(SemanticVersion lhs, SemanticVersion rhs)
 383        {
 384            if (lhs.Major > rhs.Major)
 185            {
 186                return true;
 87            }
 88
 289            if (lhs.Major == rhs.Major && lhs.Minor > rhs.Minor)
 190            {
 191                return true;
 92            }
 93
 194            return lhs.Major == rhs.Major && lhs.Minor == rhs.Minor && lhs.Patch > rhs.Patch;
 395        }
 96
 97        /// <summary>
 98        ///     Determine if <see cref="SemanticVersion" /> is greater than or equal to another <see cref="SemanticVersi
 99        /// </summary>
 100        /// <param name="lhs">Left-hand side <see cref="SemanticVersion" />.</param>
 101        /// <param name="rhs">Right-hand side <see cref="SemanticVersion" />.</param>
 102        /// <returns>
 103        ///     Returns the result of a GREATER THAN OR EQUAL operation on two <see cref="SemanticVersion" />
 104        ///     values.
 105        /// </returns>
 106        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 107        public static bool operator >=(SemanticVersion lhs, SemanticVersion rhs)
 6108        {
 6109            if (lhs.Major > rhs.Major)
 1110            {
 1111                return true;
 112            }
 113
 5114            if (lhs.Major == rhs.Major && lhs.Minor > rhs.Minor)
 1115            {
 1116                return true;
 117            }
 118
 4119            if (lhs.Major == rhs.Major && lhs.Minor == rhs.Minor && lhs.Patch > rhs.Patch)
 1120            {
 1121                return true;
 122            }
 123
 3124            return lhs.Major == rhs.Major && lhs.Minor == rhs.Minor && lhs.Patch == rhs.Patch;
 6125        }
 126
 127        /// <summary>
 128        ///     Determine if <see cref="SemanticVersion" /> is less than or equal to another <see cref="SemanticVersion"
 129        /// </summary>
 130        /// <param name="lhs">Left-hand side <see cref="SemanticVersion" />.</param>
 131        /// <param name="rhs">Right-hand side <see cref="SemanticVersion" />.</param>
 132        /// <returns>
 133        ///     Returns the result of a LESS THAN OR EQUAL operation on two <see cref="SemanticVersion" />
 134        ///     values.
 135        /// </returns>
 136        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 137        public static bool operator <=(SemanticVersion lhs, SemanticVersion rhs)
 6138        {
 6139            if (lhs.Major < rhs.Major)
 1140            {
 1141                return true;
 142            }
 143
 5144            if (lhs.Major == rhs.Major && lhs.Minor < rhs.Minor)
 1145            {
 1146                return true;
 147            }
 148
 4149            if (lhs.Major == rhs.Major && lhs.Minor == rhs.Minor && lhs.Patch < rhs.Patch)
 1150            {
 1151                return true;
 152            }
 153
 3154            return lhs.Major == rhs.Major && lhs.Minor == rhs.Minor && lhs.Patch == rhs.Patch;
 6155        }
 156
 157        /// <summary>
 158        ///     Determine if <see cref="SemanticVersion" /> is less than another <see cref="SemanticVersion" />.
 159        /// </summary>
 160        /// <param name="lhs">Left-hand side <see cref="SemanticVersion" />.</param>
 161        /// <param name="rhs">Right-hand side <see cref="SemanticVersion" />.</param>
 162        /// <returns>Returns the result of a LESS THAN operation on two <see cref="SemanticVersion" /> values.</returns>
 163        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 164        public static bool operator <(SemanticVersion lhs, SemanticVersion rhs)
 3165        {
 3166            if (lhs.Major < rhs.Major)
 1167            {
 1168                return true;
 169            }
 170
 2171            if (lhs.Major == rhs.Major && lhs.Minor < rhs.Minor)
 1172            {
 1173                return true;
 174            }
 175
 1176            return lhs.Major == rhs.Major && lhs.Minor == rhs.Minor && lhs.Patch < rhs.Patch;
 3177        }
 178
 179        /// <summary>
 180        ///     Determine if <see cref="SemanticVersion" /> is equal to another <see cref="SemanticVersion" />.
 181        /// </summary>
 182        /// <param name="lhs">Left-hand side <see cref="SemanticVersion" />.</param>
 183        /// <param name="rhs">Right-hand side <see cref="SemanticVersion" />.</param>
 184        /// <returns>Returns the result of a EQUALITY operation on two <see cref="SemanticVersion" /> values.</returns>
 185        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 186        public static bool operator ==(SemanticVersion lhs, SemanticVersion rhs)
 1187        {
 1188            return lhs.Major == rhs.Major && lhs.Minor == rhs.Minor && lhs.Patch == rhs.Patch;
 1189        }
 190
 191        /// <summary>
 192        ///     Determine if <see cref="SemanticVersion" /> does not equal than another <see cref="SemanticVersion" />.
 193        /// </summary>
 194        /// <param name="lhs">Left-hand side <see cref="SemanticVersion" />.</param>
 195        /// <param name="rhs">Right-hand side <see cref="SemanticVersion" />.</param>
 196        /// <returns>Returns the result of a NOT EQUAL operation on two <see cref="SemanticVersion" /> values.</returns>
 197        [MethodImpl(MethodImplOptions.AggressiveInlining)]
 198        public static bool operator !=(SemanticVersion lhs, SemanticVersion rhs)
 1199        {
 1200            return lhs.Major != rhs.Major || lhs.Minor != rhs.Minor || lhs.Patch != rhs.Patch;
 1201        }
 202
 203        /// <summary>
 204        ///     Does the <paramref name="obj" /> equal this <see cref="SemanticVersion" />.
 205        /// </summary>
 206        /// <param name="obj">An <see cref="object" /> to compare against.</param>
 207        /// <returns>Returns the result of an EQUALITY operation.</returns>
 208        public override bool Equals(object obj)
 1209        {
 1210            return obj is SemanticVersion other && Equals(other);
 1211        }
 212
 213        /// <summary>
 214        ///     Get the hash code of the <see cref="SemanticVersion" />.
 215        /// </summary>
 216        /// <returns>A <see cref="int" /> value.</returns>
 217        public override int GetHashCode()
 1218        {
 219            unchecked
 1220            {
 1221                int hashCode = Major;
 1222                hashCode = (hashCode * 397) ^ Minor;
 1223                hashCode = (hashCode * 397) ^ Patch;
 1224                return hashCode;
 225            }
 1226        }
 227
 228        /// <summary>
 229        ///     Does the <paramref name="otherSemanticVersion" /> equal the <see cref="SemanticVersion" />.
 230        /// </summary>
 231        /// <param name="otherSemanticVersion"></param>
 232        /// <returns>
 233        ///     The results of checking the <see cref="SemanticVersion.Major" />/<see cref="SemanticVersion.Minor" />/
 234        ///     <see cref="SemanticVersion.Patch" /> for equality.
 235        /// </returns>
 236        bool Equals(SemanticVersion otherSemanticVersion)
 1237        {
 1238            return Major == otherSemanticVersion.Major &&
 239                   Minor == otherSemanticVersion.Minor &&
 240                   Patch == otherSemanticVersion.Patch;
 1241        }
 242    }
 243}