Reading a flexbuffer

Implementing reading from a flexbuffer, enabling
most of the buffers features, like most types, maps, vectors,
typedvectors, and fixedtypedvectors.

Currently, if an offset/object cant be read we default to a swift
nil instead of the default flexbuffers 'null' with all values.

Author: mustiikhalil

swift.swiftformat

@@ -23,5 +23,6 @@
 --exclude **/*_generated.swift
 --exclude **/swift_code_*.swift
 --exclude **/*.grpc.swift
+--exclude **/Build/tests/**
 
---header "/*\n * Copyright 2024 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */"
+--header "/*\n * Copyright 2024 Google Inc. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */"

swift/Sources/Common/Constants.swift

@@ -86,6 +86,10 @@ extension Int64: Scalar {
   public typealias NumericValue = Int64
 }
 
+extension UInt: Scalar {
+  public typealias NumericValue = UInt
+}
+
 extension UInt8: Scalar {
   public typealias NumericValue = UInt8
 }

swift/Sources/FlexBuffers/ByteBuffer.swift

@@ -178,11 +178,11 @@ public struct ByteBuffer {
 
   /// The size of the elements written to the buffer + their paddings
   private var _readerIndex: Int = 0
-  /// Reader is the position of the current Writer Index (capacity - size)
-  public var reader: Int { _storage.capacity &- _readerIndex }
+//  /// Reader is the position of the current Writer Index (capacity - size)
+//  var reader: Int { _storage.capacity &- _readerIndex }
   /// Current size of the buffer
-  public var size: Int { _readerIndex }
-  /// Current capacity for the buffer
+  public var count: Int { _readerIndex }
+  /// Current capacity for the buffer including unused space
   public var capacity: Int { _storage.capacity }
 
   /// Constructor that creates a Flatbuffer object from an InternalByteBuffer
@@ -315,6 +315,68 @@ public struct ByteBuffer {
     }
   }
 
+  @inline(__always)
+  public func readUInt64(offset: Int, byteWidth: UInt8) -> UInt64 {
+    readSizedScalar(
+      def: UInt64.self,
+      t1: UInt8.self,
+      t2: UInt16.self,
+      t3: UInt32.self,
+      t4: UInt64.self,
+      position: offset,
+      byteWidth: byteWidth)
+  }
+
+  @inline(__always)
+  public func readInt64(offset: Int, byteWidth: UInt8) -> Int64 {
+    readSizedScalar(
+      def: Int64.self,
+      t1: Int8.self,
+      t2: Int16.self,
+      t3: Int32.self,
+      t4: Int64.self,
+      position: offset,
+      byteWidth: byteWidth)
+  }
+
+  @inline(__always)
+  public func readDouble(offset: Int, byteWidth: UInt8) -> Double {
+    switch byteWidth {
+    case 4:
+      Double(read(def: Float32.self, position: offset))
+    default:
+      read(def: Double.self, position: offset)
+    }
+  }
+
+  @inline(__always)
+  func readSizedScalar<
+    T: BinaryInteger,
+    T1: BinaryInteger,
+    T2: BinaryInteger,
+    T3: BinaryInteger,
+    T4: BinaryInteger
+  >(
+    def: T.Type,
+    t1: T1.Type,
+    t2: T2.Type,
+    t3: T3.Type,
+    t4: T4.Type,
+    position: Int,
+    byteWidth: UInt8) -> T
+  {
+    switch byteWidth {
+    case 1:
+      numericCast(read(def: T1.self, position: position))
+    case 2:
+      numericCast(read(def: T2.self, position: position))
+    case 4:
+      numericCast(read(def: T3.self, position: position))
+    default:
+      numericCast(read(def: T4.self, position: position))
+    }
+  }
+
   /// Reads a slice from the memory assuming a type of T
   /// - Parameters:
   ///   - index: index of the object to be read from the buffer
@@ -336,36 +398,11 @@ public struct ByteBuffer {
     }
   }
 
-  /// Provides a pointer towards the underlying primitive types
-  /// - Parameters:
-  ///   - index: index of the object to be read from the buffer
-  ///   - count: count of bytes in memory
-  @discardableResult
-  @inline(__always)
-  public func withUnsafePointerToSlice<T>(
-    index: Int,
-    count: Int,
-    body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T
-  {
-    assert(
-      index + count <= _storage.capacity,
-      "Reading out of bounds is illegal")
-    return try _storage.readWithUnsafeRawPointer(position: index) {
-      try body(UnsafeRawBufferPointer(start: $0, count: count))
-    }
-  }
-
-  #if !os(WASI)
-  /// Reads a string from the buffer and encodes it to a swift string
-  /// - Parameters:
-  ///   - index: index of the string in the buffer
-  ///   - count: length of the string
-  ///   - type: Encoding of the string
   @inline(__always)
   public func readString(
     at index: Int,
     count: Int,
-    type: String.Encoding = .utf8) -> String?
+    type: String.Encoding) -> String?
   {
     assert(
       index + count <= _storage.capacity,
@@ -379,7 +416,7 @@ public struct ByteBuffer {
         encoding: type)
     }
   }
-  #else
+
   /// Reads a string from the buffer and encodes it to a swift string
   /// - Parameters:
   ///   - index: index of the string in the buffer
@@ -396,31 +433,24 @@ public struct ByteBuffer {
       String(cString: $0.bindMemory(to: UInt8.self, capacity: count))
     }
   }
-  #endif
 
-  /// Creates a new Flatbuffer object that's duplicated from the current one
-  /// - Parameter removeBytes: the amount of bytes to remove from the current Size
-  @inline(__always)
-  public func duplicate(removing removeBytes: Int = 0) -> ByteBuffer {
-    assert(removeBytes > 0, "Can NOT remove negative bytes")
-    assert(
-      removeBytes < _storage.capacity,
-      "Can NOT remove more bytes than the ones allocated")
-    return ByteBuffer(
-      blob: _storage.retainedBlob,
-      count: _storage.capacity,
-      removing: _readerIndex &- removeBytes)
-  }
-
-  /// SkipPrefix Skips the first 4 bytes in case one of the following
-  /// functions are called `getPrefixedSizeCheckedRoot` & `getPrefixedSizeRoot`
-  /// which allows us to skip the first 4 bytes instead of recreating the buffer
+  /// Provides a pointer towards the underlying primitive types
+  /// - Parameters:
+  ///   - index: index of the object to be read from the buffer
+  ///   - count: count of bytes in memory
   @discardableResult
-  @usableFromInline
   @inline(__always)
-  mutating func skipPrefix() -> Int32 {
-    _readerIndex = _readerIndex &- MemoryLayout<Int32>.size
-    return read(def: Int32.self, position: 0)
+  public func withUnsafePointerToSlice<T>(
+    index: Int,
+    count: Int,
+    body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T
+  {
+    assert(
+      index + count <= _storage.capacity,
+      "Reading out of bounds is illegal")
+    return try _storage.readWithUnsafeRawPointer(position: index) {
+      try body(UnsafeRawBufferPointer(start: $0, count: count))
+    }
   }
 
   @discardableResult
@@ -450,15 +480,3 @@ public struct ByteBuffer {
     try _storage.readWithUnsafeRawPointer(position: position, body)
   }
 }
-
-extension ByteBuffer: CustomDebugStringConvertible {
-
-  public var debugDescription: String {
-    """
-    buffer located at: \(_storage.retainedBlob), 
-    with capacity of \(_storage.capacity),
-    { writtenSize: \(_readerIndex), readerSize: \(reader), 
-    size: \(size) }
-    """
-  }
-}

swift/Sources/FlexBuffers/Reader/FixedTypedVector.swift

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+public struct FixedTypedVector: FlexBufferVector {
+  public let byteBuffer: ByteBuffer
+  public let offset: Int
+  public let type: FlexBufferType
+  public let count: Int
+  public var isEmpty: Bool { count == 0 }
+
+  let byteWidth: UInt8
+
+  @inline(__always)
+  init(
+    byteBuffer: ByteBuffer,
+    offset: Int,
+    byteWidth: UInt8,
+    type: FlexBufferType,
+    count: Int)
+  {
+    self.byteBuffer = byteBuffer
+    self.offset = offset
+    self.byteWidth = byteWidth
+    self.type = type
+    self.count = count
+  }
+
+  @inline(__always)
+  public subscript(index: Int) -> Reference? {
+    let elementOffset = offset &+ (numericCast(index) &* numericCast(byteWidth))
+    return Reference(
+      byteBuffer: byteBuffer,
+      offset: elementOffset,
+      parentWidth: byteWidth,
+      byteWidth: 1,
+      type: type)
+  }
+}

swift/Sources/FlexBuffers/Reader/FlexBufferVector.swift

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Foundation
+
+protocol FlexBufferVector: Sized & FlexBufferContiguousBytes {
+  subscript(index: Int) -> Reference? { get }
+}
+
+extension FlexBufferVector {
+  public func jsonBuilder(json: inout String) {
+    json += "["
+    for i in 0..<count {
+      if let val = self[i]?.jsonString() {
+        let comma = i == count - 1 ? "" : ", "
+        json += "\(val)\(comma)"
+      }
+    }
+    json += "]"
+  }
+}
+
+public protocol FlexBufferContiguousBytes {
+  var byteBuffer: ByteBuffer { get }
+  var offset: Int { get }
+  var count: Int { get }
+
+  func withUnsafeRawBufferPointer<Result>(
+    _ body: (UnsafeRawBufferPointer) throws -> Result) rethrows -> Result
+}
+
+extension FlexBufferContiguousBytes {
+  public func withUnsafeRawBufferPointer<Result>(
+    _ body: (UnsafeRawBufferPointer) throws -> Result) rethrows -> Result
+  {
+    try byteBuffer.withUnsafePointerToSlice(
+      index: offset,
+      count: count,
+      body: body)
+  }
+}

swift/Sources/FlexBuffers/Reader/Map.swift

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2024 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public struct Map: Sized {
+  let byteBuffer: ByteBuffer
+  let offset: Int
+  let byteWidth: UInt8
+  public let keys: TypedVector
+  public let count: Int
+
+  public var values: Vector {
+    return Vector(byteBuffer: byteBuffer, offset: offset, byteWidth: byteWidth)
+  }
+
+  @inline(__always)
+  init(byteBuffer: ByteBuffer, offset: Int, byteWidth: UInt8) {
+    self.byteBuffer = byteBuffer
+    self.offset = offset
+    self.byteWidth = byteWidth
+
+    count = getCount(buffer: byteBuffer, offset: offset, byteWidth: byteWidth)
+    keys = TypedVector.mapKeys(
+      byteBuffer: byteBuffer,
+      offset: offset,
+      byteWidth: byteWidth)
+  }
+
+  @inline(__always)
+  public subscript(key: String) -> Reference? {
+    let count = keys.count
+    let mid = count / 2
+    guard let position = binarySearch(vector: keys, target: key)
+    else { return nil }
+
+    return getReference(at: position)
+  }
+}
+
+extension Map {
+  public func jsonBuilder(json: inout String) {
+    json += "{"
+    for i in 0..<count {
+      if let key = keys[i]?.cString {
+        let comma = i == count - 1 ? "" : ", "
+        let value = values[i]?.jsonString() ?? StaticJSON.null
+        json += "\"\(key)\": \(value)\(comma)"
+      }
+    }
+    json += "}"
+  }
+}