Merge pull request #3 from Joannis/jo/optimisations

Optimise CBOR parsing + serialization through raw APIs and Codable

Author: zamderax

Sources/CBOR/CBOR.swift

@@ -11,7 +11,7 @@ import ucrt
 // MARK: - CBOR Type
 
 /// A CBOR value
-public indirect enum CBOR: Equatable, Sendable {
+public enum CBOR: Equatable, Sendable {
     /// A positive unsigned integer
     case unsignedInt(UInt64)
     /// A negative integer
@@ -25,7 +25,7 @@ public indirect enum CBOR: Equatable, Sendable {
     /// A map of CBOR key-value pairs
     case map([CBORMapPair])
     /// A tagged CBOR value
-    case tagged(UInt64, CBOR)
+    indirect case tagged(UInt64, CBOR)
     /// A simple value
     case simple(UInt8)
     /// A boolean value
@@ -38,9 +38,13 @@ public indirect enum CBOR: Equatable, Sendable {
     case float(Double)
 
     /// Encodes the CBOR value to bytes
+    public func encode(into output: inout [UInt8]) {
+        _encode(self, into: &output)
+    }
+
     public func encode() -> [UInt8] {
         var output: [UInt8] = []
-        _encode(self, into: &output)
+        encode(into: &output)
         return output
     }
 
@@ -80,6 +84,7 @@ public struct CBORMapPair: Equatable, Sendable {
 /// - Parameters:
 ///   - value: The CBOR value to encode
 ///   - output: The output buffer to write the encoded bytes to
+@inline(__always)
 private func _encode(_ value: CBOR, into output: inout [UInt8]) {
     switch value {
     case .unsignedInt(let u):
@@ -207,16 +212,16 @@ private func _decode(reader: inout CBORReader) throws(CBORError) -> CBOR {
 
     case 2: // byte string
         let length = try readUIntValue(additional: additional, reader: &reader)
-        guard length <= UInt64(Int.max) else {
-            throw CBORError.lengthTooLarge(length)
+        guard length <= reader.maximumStringLength else {
+            throw CBORError.lengthTooLarge(length, maximum: reader.maximumStringLength)
         }
 
-        return .byteString(try reader.readBytes(Int(length)))
+        return .byteString(Array(try reader.readBytes(Int(length))))
 
     case 3: // text string
         let length = try readUIntValue(additional: additional, reader: &reader)
-        guard length <= UInt64(Int.max) else {
-            throw CBORError.lengthTooLarge(length)
+        guard length <= reader.maximumStringLength else {
+            throw CBORError.lengthTooLarge(length, maximum: reader.maximumStringLength)
         }
 
         let bytes = try reader.readBytes(Int(length))
@@ -229,25 +234,25 @@ private func _decode(reader: inout CBORReader) throws(CBORError) -> CBOR {
 
     case 4: // array
         let count = try readUIntValue(additional: additional, reader: &reader)
-        guard count <= UInt64(Int.max) else {
-            throw CBORError.lengthTooLarge(count)
+        guard count <= reader.maximumElementCount else {
+            throw CBORError.lengthTooLarge(count, maximum: reader.maximumElementCount)
         }
 
         var items: [CBOR] = []
-        for _ in 0..<Int(count) {
+        for _ in 0..<count {
             items.append(try _decode(reader: &reader))
         }
 
         return .array(items)
 
     case 5: // map
         let count = try readUIntValue(additional: additional, reader: &reader)
-        guard count <= UInt64(Int.max) else {
-            throw CBORError.lengthTooLarge(count)
+        guard count <= reader.maximumElementCount else {
+            throw CBORError.lengthTooLarge(count, maximum: reader.maximumElementCount)
         }
 
         var pairs: [CBORMapPair] = []
-        for _ in 0..<Int(count) {
+        for _ in 0..<count {
             let key = try _decode(reader: &reader)
             let value = try _decode(reader: &reader)
             pairs.append(CBORMapPair(key: key, value: value))
@@ -270,8 +275,7 @@ private func _decode(reader: inout CBORReader) throws(CBORError) -> CBOR {
             let simple = try reader.readByte()
             return .simple(simple)
         case 25: // IEEE 754 Half-Precision Float (16 bits)
-            let bytes = try reader.readBytes(2)
-            let bits = UInt16(bytes[0]) << 8 | UInt16(bytes[1])
+            let bits = try reader.readBigEndianInteger(UInt16.self)
             // Convert half-precision to double
             let sign = (bits & 0x8000) != 0
             let exponent = Int((bits & 0x7C00) >> 10)
@@ -289,15 +293,12 @@ private func _decode(reader: inout CBORReader) throws(CBORError) -> CBOR {
             return .float(sign ? -value : value)
 
         case 26: // IEEE 754 Single-Precision Float (32 bits)
-            let bytes = try reader.readBytes(4)
-            let bits = UInt32(bytes[0]) << 24 | UInt32(bytes[1]) << 16 | UInt32(bytes[2]) << 8 | UInt32(bytes[3])
+            let bits = try reader.readBigEndianInteger(UInt32.self)
             let float = Float(bitPattern: bits)
             return .float(Double(float))
 
         case 27: // IEEE 754 Double-Precision Float (64 bits)
-            let bytes = try reader.readBytes(8)
-            let bits = UInt64(bytes[0]) << 56 | UInt64(bytes[1]) << 48 | UInt64(bytes[2]) << 40 | UInt64(bytes[3]) << 32 |
-                       UInt64(bytes[4]) << 24 | UInt64(bytes[5]) << 16 | UInt64(bytes[6]) << 8 | UInt64(bytes[7])
+            let bits = try reader.readBigEndianInteger(UInt64.self)
             let double = Double(bitPattern: bits)
             return .float(double)
 
@@ -315,26 +316,20 @@ private func _decode(reader: inout CBORReader) throws(CBORError) -> CBOR {
 
 /// Reads an unsigned integer value based on the additional information.
 private func readUIntValue(additional: UInt8, reader: inout CBORReader) throws(CBORError) -> UInt64 {
-    // Check for indefinite length first
-    if additional == 31 {
-        throw CBORError.indefiniteLengthNotSupported
-    }
-    
-    if additional < 24 {
+    switch additional {
+    case 0...23:
         return UInt64(additional)
-    } else if additional == 24 {
+    case 24:
         return UInt64(try reader.readByte())
-    } else if additional == 25 {
-        let bytes = try reader.readBytes(2)
-        return UInt64(bytes[0]) << 8 | UInt64(bytes[1])
-    } else if additional == 26 {
-        let bytes = try reader.readBytes(4)
-        return UInt64(bytes[0]) << 24 | UInt64(bytes[1]) << 16 | UInt64(bytes[2]) << 8 | UInt64(bytes[3])
-    } else if additional == 27 {
-        let bytes = try reader.readBytes(8)
-        return UInt64(bytes[0]) << 56 | UInt64(bytes[1]) << 48 | UInt64(bytes[2]) << 40 | UInt64(bytes[3]) << 32 |
-               UInt64(bytes[4]) << 24 | UInt64(bytes[5]) << 16 | UInt64(bytes[6]) << 8 | UInt64(bytes[7])
-    } else {
+    case 25:
+        return try UInt64(reader.readBigEndianInteger(UInt16.self))
+    case 26:
+        return try UInt64(reader.readBigEndianInteger(UInt32.self))
+    case 27:
+        return try reader.readBigEndianInteger(UInt64.self)
+    case 31:
+        throw CBORError.indefiniteLengthNotSupported
+    default:
         throw CBORError.invalidInitialByte(additional)
     }
 }

Sources/CBOR/CBORError.swift

@@ -38,7 +38,7 @@ public enum CBORError: Error, Equatable, Sendable {
     /// This error occurs when a CBOR string, array, or map has a length that is too large
     /// to be processed by the current implementation, typically due to memory constraints.
     /// - Parameter length: The length value that exceeded the implementation's limits
-    case lengthTooLarge(UInt64)
+    case lengthTooLarge(UInt64, maximum: UInt64)
 
     /// Indefinite length encoding is not supported for this type.
     /// 
@@ -67,8 +67,8 @@ extension CBORError: CustomStringConvertible {
             return "Unexpected end of data: reached the end of input before completing the CBOR value"
         case .invalidInitialByte(let byte):
             return "Invalid initial byte: 0x\(String(byte, radix: 16, uppercase: true)) is not a valid CBOR initial byte"
-        case .lengthTooLarge(let length):
-            return "Length too large: the specified length \(length) exceeds the implementation's limits"
+        case .lengthTooLarge(let length, let maximum):
+            return "Length too large: the specified length \(length) exceeds the implementation's limits of \(maximum)"
         case .indefiniteLengthNotSupported:
             return "Indefinite length encoding not supported: this implementation does not support indefinite length encoding for this type"
         case .extraDataFound:

Sources/CBOR/CBORReader.swift

@@ -1,8 +1,9 @@
-
 /// A helper struct for reading CBOR data byte by byte
-struct CBORReader {
+struct CBORReader: ~Copyable {
     private let data: [UInt8]
     private(set) var index: Int
+    internal var maximumStringLength: UInt64 = 65_536
+    internal var maximumElementCount: UInt64 = 16_384
 
     init(data: [UInt8]) {
         self.data = data
@@ -20,14 +21,25 @@ struct CBORReader {
     }
 
     /// Read a specified number of bytes from the input
-    mutating func readBytes(_ count: Int) throws(CBORError) -> [UInt8] {
+    mutating func readBytes(_ count: Int) throws(CBORError) -> ArraySlice<UInt8> {
         guard index + count <= data.count else {
             throw CBORError.prematureEnd
         }
-        let result = Array(data[index..<index + count])
+        let result = data[index..<index + count]
         index += count
         return result
     }
+
+    mutating func readBigEndianInteger<F: FixedWidthInteger>(_ type: F.Type) throws(CBORError) -> F {
+        let bytes = try readBytes(MemoryLayout<F>.size)
+        var value: F = 0
+        return bytes.withUnsafeBytes { buffer in
+            withUnsafeMutableBytes(of: &value) { valuePtr in
+                valuePtr.copyMemory(from: buffer)
+            }
+            return value.bigEndian
+        }
+    }
 
     /// Check if there are more bytes to read
     var hasMoreBytes: Bool {
@@ -43,12 +55,4 @@ struct CBORReader {
     var totalBytes: Int {
         return data.count
     }
-    
-    /// Skip a specified number of bytes
-    mutating func skip(_ count: Int) throws(CBORError) {
-        guard index + count <= data.count else {
-            throw CBORError.prematureEnd
-        }
-        index += count
-    }
 }

Sources/CBOR/CBORCodable.swift Sources/CBOR/Codable/CBORCodable.swiftSources/CBOR/CBORCodable.swift renamed to Sources/CBOR/Codable/CBORCodable.swift

@@ -10,6 +10,11 @@ import Foundation
 extension CBOR: Encodable {
     public func encode(to encoder: Encoder) throws {
         var container = encoder.singleValueContainer()
+
+        if let container = container as? CBOREncoderSingleValueContainer {
+            container.encoder.push(self)
+            return
+        }
 
         switch self {
         case .unsignedInt(let value):
@@ -63,6 +68,11 @@ extension CBOR: Encodable {
 extension CBOR: Decodable {
     public init(from decoder: Decoder) throws {
         let container = try decoder.singleValueContainer()
+
+        if let container = container as? CBORSingleValueDecodingContainer {
+            self = container.cbor
+            return
+        }
 
         if container.decodeNil() {
             self = .null

Sources/CBOR/CBORDecoder.swift Sources/CBOR/Codable/CBORDecoder.swiftSources/CBOR/CBORDecoder.swift renamed to Sources/CBOR/Codable/CBORDecoder.swift

@@ -8,7 +8,7 @@ import Foundation
 // MARK: - CBOR Decoder
 
 /// A decoder that converts CBOR data to Swift values
-public class CBORDecoder: Decoder {
+public final class CBORDecoder: Decoder {
     private var cbor: CBOR
     public var codingPath: [CodingKey]
     public var userInfo: [CodingUserInfoKey: Any] = [:]
@@ -18,18 +18,16 @@ public class CBORDecoder: Decoder {
         self.codingPath = []
     }
 
-    public func decode<T>(_ type: T.Type, from data: Data) throws -> T where T: Decodable {
+    public func decode<T>(_ type: T.Type, from data: [UInt8]) throws -> T where T: Decodable {
         // First decode the CBOR value from the data
-        let cbor = try CBOR.decode([UInt8](data))
+        let cbor = try CBOR.decode(data)
 
         // Special case for arrays
-        if type == [Data].self {
-            if case .byteString = cbor {
-                // If we're trying to decode a byteString as an array of Data,
-                // wrap it in an array with a single element
-                let dataArray = [Data([UInt8](data))]
-                return dataArray as! T
-            }
+        if type == [Data].self, case .byteString = cbor {
+            // If we're trying to decode a byteString as an array of Data,
+            // wrap it in an array with a single element
+            let dataArray = [Data(data)]
+            return dataArray as! T
         }
 
         // Then use the regular decoder to decode the value
@@ -1538,9 +1536,9 @@ private struct CBORUnkeyedDecodingContainer: UnkeyedDecodingContainer {
 
 // MARK: - CBOR Single Value Decoding Container
 
-private struct CBORSingleValueDecodingContainer: SingleValueDecodingContainer {
+internal struct CBORSingleValueDecodingContainer: SingleValueDecodingContainer {
     var codingPath: [CodingKey]
-    private let cbor: CBOR
+    internal let cbor: CBOR
 
     init(cbor: CBOR, codingPath: [CodingKey]) {
         self.cbor = cbor