Optimize FIUUID.

Author: ShikiSuen

Sources/Megrez/9_SwiftImpl_Internals.swift

@@ -74,59 +74,149 @@ extension StringProtocol {
 
 // MARK: - FIUUID
 
-/// A simple UUID v4 implementation without Foundation.
-/// Generates a random 128-bit UUID compliant with RFC 4122.
+/// A lightweight pseudo-UUID，採用兩個 UInt64 儲存 128 位元識別值，以維持標準 UUID 字串格式且降低陣列開銷。
+@frozen
 public struct FIUUID: Hashable, Codable, Sendable {
   // MARK: Lifecycle
 
   public init() {
-    var rng = SystemRandomNumberGenerator()
-    self.bytes = Self.randomBytes(count: 16, using: &rng)
-    // Set version to 4
-    bytes[6] = (bytes[6] & 0x0F) | 0x40
-    // Set variant to 1 (RFC 4122)
-    bytes[8] = (bytes[8] & 0x3F) | 0x80
+    self.highBits = UInt64.random(in: UInt64.min ... UInt64.max)
+    self.lowBits = UInt64.random(in: UInt64.min ... UInt64.max)
+  }
+
+  public init(highBits: UInt64, lowBits: UInt64) {
+    self.highBits = highBits
+    self.lowBits = lowBits
+  }
+
+  /// 與先前 64 位元版本相容：會將值儲存在低位元，並將高位元清零。
+  public init(rawValue: UInt64) {
+    self.highBits = 0
+    self.lowBits = rawValue
+  }
+
+  public init(from decoder: any Decoder) throws {
+    let container = try decoder.singleValueContainer()
+
+    if let stringValue = try? container.decode(String.self) {
+      guard let decoded = FIUUID(uuidString: stringValue) else {
+        throw DecodingError.dataCorruptedError(
+          in: container,
+          debugDescription: "Invalid UUID string for FIUUID."
+        )
+      }
+      self = decoded
+      return
+    }
+
+    if let pair = try? container.decode([UInt64].self), pair.count == 2 {
+      self.init(highBits: pair[0], lowBits: pair[1])
+      return
+    }
+
+    if let legacyRaw = try? container.decode(UInt64.self) {
+      self.init(rawValue: legacyRaw)
+      return
+    }
+
+    throw DecodingError.dataCorruptedError(
+      in: container,
+      debugDescription: "Unsupported FIUUID encoding."
+    )
+  }
+
+  /// 依照 UUID 字串初始化識別值，支援大小寫。
+  public init?(uuidString: String) {
+    let filtered = uuidString.filter { $0 != "-" }
+    guard filtered.count == 32 else { return nil }
+
+    var bytes: [UInt8] = []
+    bytes.reserveCapacity(16)
+
+    var index = filtered.startIndex
+    for _ in 0 ..< 16 {
+      let highChar = filtered[index]
+      index = filtered.index(after: index)
+      let lowChar = filtered[index]
+      index = filtered.index(after: index)
+
+      guard let high = Self.hexValue(of: highChar),
+            let low = Self.hexValue(of: lowChar)
+      else { return nil }
+
+      bytes.append((high << 4) | low)
+    }
+
+    self.init(bytes: bytes)
+  }
+
+  private init(bytes: [UInt8]) {
+    self.highBits = Self.readBigEndian(from: bytes, offset: 0)
+    self.lowBits = Self.readBigEndian(from: bytes, offset: 8)
   }
 
   // MARK: Public
 
-  /// Returns the UUID as a standard hyphenated string (e.g., "123e4567-e89b-12d3-a456-426614174000").
-  public func uuidString() -> String {
-    let hexDigits = bytes.map { byte in
-      let hex = String(byte, radix: 16)
-      return hex.count == 1 ? "0" + hex : hex
+  /// 高 64 位元與低 64 位元的原始識別值。
+  public let highBits: UInt64
+  public let lowBits: UInt64
+
+  /// 以標準 UUID 字串形式返回識別值（預設為大寫）。
+  public func uuidString(uppercase: Bool = true) -> String {
+    var bytes = [UInt8](repeating: 0, count: 16)
+    Self.write(bigEndian: highBits, to: &bytes, offset: 0)
+    Self.write(bigEndian: lowBits, to: &bytes, offset: 8)
+
+    let hexDigits = uppercase ? Self.upperHexDigits : Self.lowerHexDigits
+    var characters: [Character] = []
+    characters.reserveCapacity(36)
+
+    for index in 0 ..< bytes.count {
+      if index == 4 || index == 6 || index == 8 || index == 10 {
+        characters.append("-")
+      }
+      let byte = bytes[index]
+      characters.append(hexDigits[Int(byte >> 4)])
+      characters.append(hexDigits[Int(byte & 0x0F)])
     }
-    let hexString = hexDigits.joined()
-    let part1 = hexString.prefix(8)
-    let part2 = hexString.dropFirst(8).prefix(4)
-    let part3 = hexString.dropFirst(12).prefix(4)
-    let part4 = hexString.dropFirst(16).prefix(4)
-    let part5 = hexString.suffix(12)
-    return "\(part1)-\(part2)-\(part3)-\(part4)-\(part5)"
+
+    return String(characters)
+  }
+
+  public func encode(to encoder: any Encoder) throws {
+    var container = encoder.singleValueContainer()
+    try container.encode(uuidString())
   }
 
   // MARK: Private
 
-  private var bytes: [UInt8]
-
-  private static func randomBytes(
-    count: Int,
-    using rng: inout SystemRandomNumberGenerator
-  )
-    -> [UInt8] {
-    var result = [UInt8](repeating: 0, count: count)
-    var offset = 0
-    while offset < count {
-      let randomValue = rng.next()
-      withUnsafeBytes(of: randomValue) { buffer in
-        let bytesToCopy = min(8, count - offset)
-        let byteCount = min(bytesToCopy, buffer.count)
-        for i in 0 ..< byteCount {
-          result[offset + i] = buffer[i]
-        }
-        offset += byteCount
-      }
+  private static let upperHexDigits: [Character] = Array("0123456789ABCDEF")
+  private static let lowerHexDigits: [Character] = Array("0123456789abcdef")
+
+  private static func write(bigEndian value: UInt64, to buffer: inout [UInt8], offset: Int) {
+    for index in 0 ..< 8 {
+      buffer[offset + index] = UInt8(truncatingIfNeeded: value >> (8 * (7 - index)))
+    }
+  }
+
+  private static func readBigEndian(from buffer: [UInt8], offset: Int) -> UInt64 {
+    var result: UInt64 = 0
+    for index in 0 ..< 8 {
+      result = (result << 8) | UInt64(buffer[offset + index])
     }
     return result
   }
+
+  private static func hexValue(of character: Character) -> UInt8? {
+    switch character {
+    case "0" ... "9":
+      return UInt8(character.unicodeScalars.first!.value - Unicode.Scalar("0").value)
+    case "a" ... "f":
+      return UInt8(character.unicodeScalars.first!.value - Unicode.Scalar("a").value + 10)
+    case "A" ... "F":
+      return UInt8(character.unicodeScalars.first!.value - Unicode.Scalar("A").value + 10)
+    default:
+      return nil
+    }
+  }
 }

Tests/MegrezTests/NodeOverrideStatusTests.swift

@@ -23,10 +23,11 @@ final class NodeOverrideStatusTests: XCTestCase {
     // 確保每個 UUID 都是唯一的
     XCTAssertNotEqual(uuid1, uuid2)
 
-    // 測試 UUID 字符串格式
+    // 測試 UUID 字串格式
     let uuidString = uuid1.uuidString()
-    XCTAssertEqual(uuidString.count, 36) // 標準 UUID 格式長度
+    XCTAssertEqual(uuidString.count, 36)
     XCTAssertTrue(uuidString.contains("-"))
+    XCTAssertTrue(uuidString.allSatisfy { $0 == "-" || "0123456789ABCDEF".contains($0) })
 
     // 測試 Codable
     let encoder = JSONEncoder()