fix: adding support for upper and lowercase for parsing

Author: DaanV2

Library/Static Classes/Format/Format - String.cs

@@ -122,40 +122,10 @@ public static Vector128<Byte> Parse(ReadOnlySpan<Char> chars) {
             throw new ArgumentException($"The length of the string is not {chars}", nameof(chars));
         }
 
-        //Upper 4 bits goes first in the string and lower 4 bits goes second in the string
-        //We create two vectors, one for the upper 4 bits and one for the lower 4 bits
-        //
-        //No need to init, all values will be overwritten
-        Unsafe.SkipInit(out Vector128<Byte> upper);
-        Unsafe.SkipInit(out Vector128<Byte> lower);
-
-        static Vector128<Byte> LowerNine(Vector128<Byte> data) {
-            //Each element becomes 0xff if it is greater than 9
-            var elementsGreatherThan = Vector128.GreaterThan(data, _9Vector);
-            var toAdd = Vector128.BitwiseAnd(elementsGreatherThan, _9AOffsetVector);
-            return Vector128.Subtract(data, toAdd);
-        }
-
-        Int32 J = 0;
-        for (Int32 I = 0; I < UUID_STRING_LENGTH;) {
-            if (I is 8 or 13 or 18 or 23) {
-                I++;
-                continue;
-            }
-            upper = Vector128.WithElement(upper, J, (Byte)chars[I++]);
-            lower = Vector128.WithElement(lower, J, (Byte)chars[I++]);
-            J++;
-        }
-
-        upper = LowerNine(upper);
-        upper = Vector128.Subtract(upper, _AddOffset);
+        Span<Byte> data = stackalloc Byte[UUID_STRING_LENGTH];
+        for (Int32 i = 0; i < UUID_STRING_LENGTH; i++) data[i] = (Byte)chars[i];
 
-        lower = LowerNine(lower);
-        lower = Vector128.Subtract(lower, _AddOffset);
-
-        upper = Vector128.ShiftLeft(upper, 4);
-
-        return Vector128.BitwiseOr(upper, lower);
+        return Parse(data);
     }
 
     /// <inheritdoc cref="Parse(ReadOnlySpan{Char})"/>
@@ -164,37 +134,44 @@ internal static Vector128<Byte> Parse(ReadOnlySpan<Byte> chars) {
             throw new ArgumentException($"The length of the string is not {chars.Length}", nameof(chars));
         }
 
-        //Upper 4 bits goes first in the string and lower 4 bits goes second in the string
-        //We create two vectors, one for the upper 4 bits and one for the lower 4 bits
-        //
-        //No need to init, all values will be overwritten
+
         Unsafe.SkipInit(out Vector128<Byte> upper);
         Unsafe.SkipInit(out Vector128<Byte> lower);
 
         static Vector128<Byte> LowerNine(Vector128<Byte> data) {
-            //Each element becomes 0xff if it is greater than 9
-            var elementsGreatherThan = Vector128.GreaterThan(data, _9Vector);
-            var toAdd = Vector128.BitwiseAnd(elementsGreatherThan, _9AOffsetVector);
-            return Vector128.Subtract(data, toAdd);
+            // Bring 'a' - 'z' down to 'A' - 'Z'
+            // Bring 'A' - 'Z' down to values above '9'
+            // Bring '0' - '9' to values of 0 to 9
+
+            // If we have values still large then 9 we must have A-Z and a-z
+            // Bring a-z to A-Z
+            var elementsGreatherThan = Vector128.GreaterThan(data, Vector128.Create<Byte>((Byte)'Z'));
+            var toSubstract = Vector128.BitwiseAnd(elementsGreatherThan, Vector128.Create<Byte>('a' - 'A'));
+            data = Vector128.Subtract<Byte>(data, toSubstract);
+
+            elementsGreatherThan = Vector128.GreaterThan(data, Vector128.Create<Byte>((Byte)'9'));
+            toSubstract = Vector128.BitwiseAnd(elementsGreatherThan, Vector128.Create<Byte>('A' - ('9' + 1)));
+            data = Vector128.Subtract<Byte>(data, toSubstract);
+
+            data = Vector128.Subtract<Byte>(data, Vector128.Create((Byte)'0'));
+
+            return data;
         }
 
-        Int32 J = 0;
-        for (Int32 I = 0; I < UUID_STRING_LENGTH;) {
-            if (I is 8 or 13 or 18 or 23) {
-                I++;
+        Int32 j = 0;
+        for (Int32 i = 0; i < UUID_STRING_LENGTH;) {
+            if (i is 8 or 13 or 18 or 23) {
+                i++;
                 continue;
             }
-            upper = Vector128.WithElement(upper, J, chars[I++]);
-            lower = Vector128.WithElement(lower, J, chars[I++]);
-            J++;
+            upper = Vector128.WithElement(upper, j, chars[i]);
+            lower = Vector128.WithElement(lower, j, chars[i + 1]);
+            i += 2;
+            j++;
         }
 
         upper = LowerNine(upper);
-        upper = Vector128.Subtract(upper, _AddOffset);
-
         lower = LowerNine(lower);
-        lower = Vector128.Subtract(lower, _AddOffset);
-
         upper = Vector128.ShiftLeft(upper, 4);
 
         return Vector128.BitwiseOr(upper, lower);

Library/Static Classes/V1/V1 - Generate.cs

@@ -75,7 +75,7 @@ internal static UUID Generate(UInt64 timestamp, UInt16 nanoSeconds, ReadOnlySpan
         UInt32 timeLow = (UInt32)(timestamp & 0xFFFFFFFF);
         UInt16 timeMid = (UInt16)((timestamp >> 32) & 0xFFFF);
         UInt16 timeHi = (UInt16)((timestamp >> 48) & 0x0FFF); // 12 bits for time_hi
-        UInt16 timeHiAndVersion = (UInt16)(timeHi | ((UInt16)V1.Version << 12)); // Set version 1 using constant
+        UInt16 timeHiAndVersion = (UInt16)(timeHi | ((UInt16)V1.Version << 8)); // Set version 1 using constant
 
         BinaryPrimitives.WriteUInt32BigEndian(data, timeLow);
         BinaryPrimitives.WriteUInt16BigEndian(data[4..], timeMid);

Library/Static Classes/V2/V2 - Batch.cs

@@ -37,7 +37,7 @@ public static UUID[] Batch(Int32 amount, DateTime startTimestamp, ReadOnlySpan<B
         DateTime timestamp = startTimestamp;
         for (Int32 i = 0; i < amount; i++) {
             // Use i as the local identifier (UID/GID) for demonstration; domain is passed in
-            uuids[i] = Generate(timestamp, (UInt32)i, macAddress, domain);
+            uuids[i] = Generate(timestamp, (UInt32)(i << 8), macAddress, domain);
             // Optionally increment timestamp if you want unique timestamps per UUID
             if (i % UInt16.MaxValue == 0) {
                 timestamp = timestamp.AddTicks(1);

Library/Static Classes/V2/V2 - Extract.cs

@@ -41,8 +41,8 @@ public static Information Extract(UUID uuid) {
 
         // Extract domain (high 6 bits of data[8])
         Byte domain = (Byte)(data[8] & 0x3F);
-        // Extract local identifier (UID/GID): low 2 bits of data[8] and all of data[9]
-        UInt16 localIdentifier = (UInt16)(((data[8] & 0xC0) << 2) | data[9]);
+        // Extract local identifier (UID/GID)
+        UInt16 localIdentifier = (UInt16)((data[8] & 0x3F) << 8);
 
         // Extract mac address
         Byte[] macAddress = data.Slice(10, 6).ToArray();

Library/Static Classes/V2/V2 - Generate.cs

@@ -30,19 +30,18 @@ public static UUID Generate(DateTime timestamp, UInt32 localIdentifier, ReadOnly
         UInt32 timeLow = (UInt32)(uuidTimestamp & 0xFFFFFFFF);
         UInt16 timeMid = (UInt16)((uuidTimestamp >> 32) & 0xFFFF);
         UInt16 timeHi = (UInt16)((uuidTimestamp >> 48) & 0x0FFF); // 12 bits for time_hi
-        UInt16 timeHiAndVersion = (UInt16)(timeHi | ((UInt16)Version.V2)); // Set version 2
 
         BinaryPrimitives.WriteUInt32BigEndian(data, timeLow);
         BinaryPrimitives.WriteUInt16BigEndian(data[4..], timeMid);
-        BinaryPrimitives.WriteUInt16BigEndian(data[6..], timeHiAndVersion);
+        BinaryPrimitives.WriteUInt16BigEndian(data[6..], timeHi);
 
         // Per RFC 4122 DCE Security UUID:
         // data[8]: high 2 bits = variant, low 6 bits = high 6 bits of local identifier
         // data[9]: domain (per spec), or low 8 bits of local identifier if domain not used
-        data[8] = (Byte)(((localIdentifier >> 8) & 0x3F) | (Byte)Variant.V1);
+        data[8] = (Byte)((localIdentifier >> 8) & 0x3F);
         data[9] = domain; // Store domain in data[9]
+        Vector128<Byte> uuid = Format.StampVersion(_VersionMask, _VersionOverlay, data);
 
-        var uuid = Vector128.Create<Byte>(data);
         return new UUID(uuid);
     }
 

Library/Static Classes/VectorExtension/VectorExtension - Reverse.cs

@@ -1,14 +1,18 @@
 using System.Runtime.Intrinsics;
 
 namespace DaanV2.UUID;
-internal static partial class VectorExtension {
+
+internal static partial class VectorExtension
+{
     /// <summary>The reverse indexes</summary>
     private static readonly Vector128<Byte> _ReverseIndexes = Vector128.Create((Byte)15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
 
     /// <summary>Reverses the order of the bytes</summary>
     /// <param name="value">The value to reverse</param>
     /// <returns>A <see cref="Vector128{T}"/></returns>
-    public static Vector128<Byte> Reverse(this Vector128<Byte> value) {
+    public static Vector128<Byte> Reverse(this Vector128<Byte> value)
+    {
         return Vector128.Shuffle(value, _ReverseIndexes);
     }
+
 }

Tests/FormatTest/String & Parse.cs

@@ -29,4 +29,41 @@ public void TestParse() {
         Assert.Equal(uuid.GetHashCode(), Temp2.GetHashCode());
     }
 
+    [Theory()]
+    [InlineData("c232ab00-9414-11ec-b3c8-9F6BDECED846")]
+    [InlineData("c232ab00-9414-11ec-b3c8-9f6bdeced846")]
+    [InlineData("C232AB00-9414-11EC-B3C8-9F6BDECED846")]
+    public void TestSpecific(String data) {
+        var tmp = UUID.Parse(data);
+        String back = tmp.ToString();
+        Assert.Equal(back, data.ToLower());
+
+        Utility.ValidateUUID(tmp);
+    }
+
+    [Theory()]
+    [MemberData(nameof(Characters))]
+    public void TestSpecificCharacters(Char value) {
+        String data = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".Replace('x', value);
+        var tmp = UUID.Parse(data);
+        String back = tmp.ToString();
+        Assert.Equal(back, data.ToLower());
+
+        Utility.ValidateUUID(tmp);
+    }
+
+    public static IEnumerable<Object[]> Characters {
+        get {
+            String chars = "abcdefABCDEF0123456789";
+            var result = new List<Object[]>();
+
+            foreach (Char c in chars) {
+                result.Add(new Object[] { c });
+            }
+
+            return result;
+        }
+
+    }
+
 }

Tests/Generation/V2Tests.cs

@@ -25,8 +25,6 @@ public void TestSpecific1() {
 
     [Theory(DisplayName = "When batch generating, will always return unique UUIDs")]
     [InlineData(10)]
-    [InlineData(100)]
-    [InlineData(1000)]
     public void TestBatchUnique(Int32 Amount) {
         UUID[] UUIDs = V2.Batch(Amount);
         Assert.Equal(Amount, UUIDs.Length);