feat: adding V2

Author: DaanV2

Library/DaanV2.UUID.Net.csproj

@@ -17,7 +17,7 @@
     <SignAssembly>False</SignAssembly>
     <Description>A library that provides a way to handle and generate UUIDs. Convert them to and from strings, GUIDs, and the like. 
 The library is written to be fast and efficient when comparing, generating, or handling operations. Provides ways to generate UUIDs from different data, like a string, a byte array, or cutting up a byte array into UUIDs.
-Complies with the RFC 4122 standard. And has version 1-8 UUIDs implemented. except 2. Which I haven't been able to figure out how to implement.</Description>
+Complies with the RFC 4122 / RFC 9562 standard. And has version 1-8 UUIDs implemented.</Description>
     <PackageProjectUrl>https://github.com/DaanV2/DaanV2.UUID.Net</PackageProjectUrl>
     <PackageIcon>icon.png</PackageIcon>
     <PackageReadmeFile>README.md</PackageReadmeFile>

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

@@ -58,32 +58,35 @@ public static UUID Generate(DateTime timestamp, UInt16 nanoSeconds, ReadOnlySpan
     /// <returns>A new <see cref="UUID"/></returns>
     [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
     internal static UUID Generate(UInt64 timestamp, UInt16 nanoSeconds, ReadOnlySpan<Byte> macAddress) {
-        //First 32 bites = time_low
-        //Next 16 bites = time_mid
-        //Next 16 bites = time_hi_version = time_high | version
-        //next 8 bites = clock_seq_hi_variant 
-        //next 8 bites = clock_seq_low | node
-        //last 48 bites mac address
+        // RFC 4122 layout:
+        // 0-3: time_low
+        // 4-5: time_mid
+        // 6-7: time_hi_and_version
+        // 8:   clock_seq_hi_and_reserved (variant in high bits)
+        // 9:   clock_seq_low
+        // 10-15: node (MAC address)
 
         Span<Byte> data = stackalloc Byte[Format.UUID_BYTE_LENGTH];
 
-        //mac is 6 bytes, transfer to 8 bytes and use BinaryPrimitives to convert to UInt64
+        // Write node (MAC address)
         macAddress.CopyTo(data[10..]);
-        var read = Vector64.Create<UInt64>(timestamp);
 
-        //Setting timelow to be the 32 least significant bits of the timestamp
-        UInt32 timeLow = read.AsUInt32().GetElement(0);
+        // Split timestamp
+        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 | (1 << 12)); // Set version 1
+
         BinaryPrimitives.WriteUInt32BigEndian(data, timeLow);
-        //Next 16 bites = time_mid
-        UInt16 timeMid = read.AsUInt16().GetElement(2);
         BinaryPrimitives.WriteUInt16BigEndian(data[4..], timeMid);
-        //Next 16 bites = time_hi_version = time_high | version
-        UInt16 timeHiVersion = read.AsUInt16().GetElement(3);
-        BinaryPrimitives.WriteUInt16BigEndian(data[6..], timeHiVersion);
-        BinaryPrimitives.WriteUInt16BigEndian(data[8..], nanoSeconds);
+        BinaryPrimitives.WriteUInt16BigEndian(data[6..], timeHiAndVersion);
+
+        // Split nanoSeconds (clock sequence) into 14 bits
+        UInt16 clockSeq = (UInt16)(nanoSeconds & 0x3FFF);
+        data[8] = (byte)(((clockSeq >> 8) & 0x3F) | 0x80); // Set variant (10xxxxxx)
+        data[9] = (byte)(clockSeq & 0xFF);
 
         var uuid = Vector128.Create<Byte>(data);
-        uuid = Format.StampVersion(V1._VersionMask, V1._VersionOverlay, uuid);
         return new UUID(uuid);
     }
 }

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

@@ -0,0 +1,47 @@
+using System.Runtime.CompilerServices;
+
+namespace DaanV2.UUID;
+
+public static partial class V2 {
+    /// <inheritdoc cref="Batch(Int32, DateTime, ReadOnlySpan{Byte})"/>
+
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static UUID[] Batch(Int32 amount, byte domain = 0) {
+        return Batch(amount, DateTime.UtcNow, V1.GetMacAddressBytes(), domain);
+    }
+
+    /// <inheritdoc cref="Batch(Int32, DateTime, ReadOnlySpan{Byte})"/>
+
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static UUID[] Batch(Int32 amount, DateTime startTimestamp, byte domain = 0) {
+        return Batch(amount, startTimestamp, V1.GetMacAddressBytes(), domain);
+    }
+
+    /// <inheritdoc cref="Batch(Int32, DateTime, ReadOnlySpan{Byte})"/>
+
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static UUID[] Batch(Int32 amount, ReadOnlySpan<Byte> macAddress, byte domain = 0) {
+        return Batch(amount, DateTime.UtcNow, macAddress, domain);
+    }
+
+    /// <summary>Creates a batch of <see cref="UUID"/>, Note: This function use <see cref="DateTime.Now"/> To grab a starting point, 
+    /// but will increment the timestamp to create a new <see cref="UUID"/></summary>
+    /// <param name="amount">The amount of <see cref="UUID"/> to create</param>
+    /// <param name="startTimestamp">The time to start at, will increment for each following <see cref="UUID"/></param>
+    /// <param name="macAddress">The macAddress to use, excepts to be 6 bytes</param>
+    /// <returns>A collection of <see cref="UUID"/></returns>
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static UUID[] Batch(Int32 amount, DateTime startTimestamp, ReadOnlySpan<Byte> macAddress, byte domain = 0) {
+        var uuids = new UUID[amount];
+        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, (uint)i, macAddress, domain);
+            // Optionally increment timestamp if you want unique timestamps per UUID
+            if (i % UInt16.MaxValue == 0) {
+                timestamp = timestamp.AddTicks(1);
+            }
+        }
+        return uuids;
+    }
+}

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

@@ -0,0 +1,16 @@
+using System.Runtime.Intrinsics;
+using System.Security.Cryptography;
+
+namespace DaanV2.UUID;
+
+public static partial class V2 {
+    /// <inheritdoc cref="V2.Version"/>
+    public const Version Version = DaanV2.UUID.Version.V2;
+    /// <inheritdoc cref="V2.Variant"/>
+    public const Variant Variant = DaanV2.UUID.Variant.V1;
+    /// <summary>The prefered minimum data length for chunking bytes array</summary>
+    public const Int32 MinimumDataLength = MD5.HashSizeInBytes;
+
+    private static readonly Vector128<Byte> _VersionMask = Format.VersionVariantMaskNot(V2.Version, V2.Variant);
+    private static readonly Vector128<Byte> _VersionOverlay = Format.VersionVariantOverlayer(V2.Version, V2.Variant);
+}

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

@@ -0,0 +1,57 @@
+using System.Buffers.Binary;
+using System.Runtime.Intrinsics;
+
+namespace DaanV2.UUID;
+
+public static partial class V2 {
+    /// <summary>A record of what information can be returned by a <see cref="UUID"/> of version 2 (DCE Security)</summary>
+    public record Information {
+        /// <summary>The timestamp it was made at (may be imprecise due to overlays)</summary>
+        public DateTime Timestamp { get; init; }
+        /// <summary>The local identifier (UID/GID) embedded in the UUID</summary>
+        public UInt16 LocalIdentifier { get; init; }
+        /// <summary>The domain (person, group, org) embedded in the UUID</summary>
+        public Byte Domain { get; init; }
+        /// <summary>The mac address of the machine it was made on</summary>
+        public required Byte[] MacAddress { get; init; }
+    }
+
+    /// <summary>Extract from the given <see cref="UUID"/> its information record, if made with <see cref="V2"/></summary>
+    /// <param name="uuid">The <see cref="UUID"/> to extract from</param>
+    /// <returns>A record of <see cref="Information"/></returns>
+    public static Information Extract(UUID uuid) {
+        Span<Byte> data = stackalloc Byte[Format.UUID_BYTE_LENGTH];
+        uuid._Data.CopyTo(data);
+
+        // Extract time_low (first 32 bits)
+        UInt32 timeLow = BinaryPrimitives.ReadUInt32BigEndian(data);
+        UInt64 timestampTicks = (UInt64)timeLow;
+
+        // Extract time_mid (next 16 bits)
+        UInt16 timeMid = BinaryPrimitives.ReadUInt16BigEndian(data[4..]);
+        timestampTicks |= (UInt64)timeMid << 32;
+
+        // Extract time_hi_version (next 16 bits)
+        UInt16 timeHiVersion = BinaryPrimitives.ReadUInt16BigEndian(data[6..]);
+        timestampTicks |= (UInt64)(timeHiVersion & 0x0FFF) << 48; // Clear version bits
+
+        // Convert timestampTicks to DateTime (uses V1 epoch, as V2 overlays V1 layout)
+        Int64 timestampFileTime = (Int64)(timestampTicks - V1.Epoch);
+        var timestamp = DateTime.FromFileTimeUtc(timestampFileTime);
+
+        // 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 mac address
+        Byte[] macAddress = data.Slice(10, 6).ToArray();
+
+        return new Information() {
+            MacAddress = macAddress,
+            LocalIdentifier = localIdentifier,
+            Domain = domain,
+            Timestamp = timestamp
+        };
+    }
+}

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

@@ -0,0 +1,77 @@
+using System.Buffers.Binary;
+using System.Runtime.CompilerServices;
+using System.Runtime.Intrinsics;
+using System.Runtime.InteropServices;
+using System;
+
+namespace DaanV2.UUID;
+
+public static partial class V2 {
+    /// <summary>
+    /// Generates a Version 2 (DCE Security) UUID using the current time, UID, and MAC address.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static UUID Generate() {
+        // Use current time, current UID, and MAC address
+        return Generate(DateTime.UtcNow, GetCurrentUid(), V1.GetMacAddressBytes());
+    }
+
+    /// <summary>
+    /// Generates a Version 2 UUID with custom timestamp, UID, and MAC address.
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveOptimization)]
+    public static UUID Generate(DateTime timestamp, uint localIdentifier, ReadOnlySpan<byte> macAddress, byte domain = 0) {
+        ulong uuidTimestamp = V1.TimeStamp(timestamp);
+
+        Span<byte> data = stackalloc byte[16];
+
+        // Write node (MAC address)
+        macAddress.CopyTo(data[10..]);
+
+        // Split timestamp
+        uint timeLow = (uint)(uuidTimestamp & 0xFFFFFFFF);
+        ushort timeMid = (ushort)((uuidTimestamp >> 32) & 0xFFFF);
+        ushort timeHi = (ushort)((uuidTimestamp >> 48) & 0x0FFF); // 12 bits for time_hi
+        ushort timeHiAndVersion = (ushort)(timeHi | (_Version << 12)); // Set version 2
+
+        BinaryPrimitives.WriteUInt32BigEndian(data, timeLow);
+        BinaryPrimitives.WriteUInt16BigEndian(data[4..], timeMid);
+        BinaryPrimitives.WriteUInt16BigEndian(data[6..], timeHiAndVersion);
+
+        // 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)(_Variant | ((localIdentifier >> 8) & 0x3F));
+        data[9] = domain; // Store domain in data[9]
+
+        var uuid = Vector128.Create<Byte>(data);
+        return new UUID(uuid);
+    }
+
+    /// <summary>
+    /// Gets the current user's UID (Linux only). Returns 0 if not available.
+    /// </summary>
+    private static uint GetCurrentUid() {
+        try {
+            return (uint)System.Convert.ToInt32(Environment.GetEnvironmentVariable("UID") ?? "0");
+        } catch {
+            return 0;
+        }
+    }
+
+    /// <summary>
+    /// Generates a Version 2 UUID from a byte source (not standard, but for API compatibility).
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveOptimization | MethodImplOptions.AggressiveInlining)]
+    public static UUID Generate(ReadOnlySpan<Byte> source) {
+        // Not standard for V2, but for API compatibility: hash and overlay version/variant
+        Span<byte> data = stackalloc byte[16];
+        System.Security.Cryptography.MD5.HashData(source, data);
+        // Set version and variant
+        data[6] = (byte)((data[6] & 0x0F) | (_Version << 4));
+        data[8] = (byte)((data[8] & 0x3F) | _Variant);
+
+        var uuid = Vector128.Create<Byte>(data);
+        return new UUID(uuid);
+    }
+}

Library/Static Classes/V2/V2.cs

@@ -0,0 +1,6 @@
+namespace DaanV2.UUID;
+
+/// <summary>The <see cref="UUID"/> tjat os nased pm DCE Security, with embedded POSIX UIDs.</summary>
+public static partial class V2 {
+
+}

README.md

@@ -7,7 +7,7 @@
 
 A library that provides a way to handle and generate UUIDs. Convert them to and from strings, GUIDs, and the like. 
 The library is written to be fast and efficient when comparing, generating, or handling operations. Provides ways to generate UUIDs from different data, like a string, a byte array, or cutting up a byte array into UUIDs.
-Complies with the RFC 4122 standard. And has version 1-8 UUIDs implemented. except 2. Which I haven't been able to figure out how to implement.
+Complies with the RFC 4122 / RFC 9562 standard. And has version 1-8 UUIDs implemented.
 
 ## Usage Example
 Below are two examples of generating UUIDs and usage