[Swift] Implements FlatbuffersVector which confirms to RandomAccessCollection (#8752)

* Implements FlatbuffersVector in swift

Implements FlatbuffersVector which confirms to RandomAccessCollection,
this would give us semi-native sugary syntax to all the arrays in swift port.

This work will also be the foundation of using arrays in swift

* Fix failing tests for Swift

swift/Sources/FlatBuffers/ByteBuffer.swift

@@ -29,8 +29,8 @@ public struct ByteBuffer {
     @usableFromInline
     enum Blob {
       #if !os(WASI)
-        case data(Data)
-        case bytes(ContiguousBytes)
+      case data(Data)
+      case bytes(ContiguousBytes)
       #endif
 
       case byteBuffer(_InternalByteBuffer)
@@ -96,16 +96,16 @@ public struct ByteBuffer {
     @inline(__always)
     func withUnsafeBytes<T>(
       _ body: (UnsafeRawBufferPointer) throws
-        -> T
-    ) rethrows -> T {
+        -> T) rethrows -> T
+    {
       switch retainedBlob {
       case .byteBuffer(let byteBuffer):
         return try byteBuffer.withUnsafeBytes(body)
       #if !os(WASI)
-        case .data(let data):
-          return try data.withUnsafeBytes(body)
-        case .bytes(let contiguousBytes):
-          return try contiguousBytes.withUnsafeBytes(body)
+      case .data(let data):
+        return try data.withUnsafeBytes(body)
+      case .bytes(let contiguousBytes):
+        return try contiguousBytes.withUnsafeBytes(body)
       #endif
       case .array(let array):
         return try array.withUnsafeBytes(body)
@@ -118,21 +118,21 @@ public struct ByteBuffer {
     @inline(__always)
     func withUnsafeRawPointer<T>(
       _ body: (UnsafeMutableRawPointer) throws
-        -> T
-    ) rethrows -> T {
+        -> T) rethrows -> T
+    {
       switch retainedBlob {
       case .byteBuffer(let byteBuffer):
         return try byteBuffer.withUnsafeRawPointer(body)
       #if !os(WASI)
-        case .data(let data):
-          return
-            try data
+      case .data(let data):
+        return
+          try data
             .withUnsafeBytes {
               try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
             }
-        case .bytes(let contiguousBytes):
-          return
-            try contiguousBytes
+      case .bytes(let contiguousBytes):
+        return
+          try contiguousBytes
             .withUnsafeBytes {
               try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
             }
@@ -140,9 +140,9 @@ public struct ByteBuffer {
       case .array(let array):
         return
           try array
-          .withUnsafeBytes {
-            try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
-          }
+            .withUnsafeBytes {
+              try body(UnsafeMutableRawPointer(mutating: $0.baseAddress!))
+            }
       case .pointer(let ptr):
         return try body(ptr)
       }
@@ -152,20 +152,20 @@ public struct ByteBuffer {
     @inline(__always)
     func readWithUnsafeRawPointer<T>(
       position: Int,
-      _ body: (UnsafeRawPointer) throws -> T
-    ) rethrows -> T {
+      _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
+    {
       switch retainedBlob {
       case .byteBuffer(let byteBuffer):
         return try byteBuffer.readWithUnsafeRawPointer(position: position, body)
       #if !os(WASI)
-        case .data(let data):
-          return try data.withUnsafeBytes {
-            try body($0.baseAddress!.advanced(by: position))
-          }
-        case .bytes(let contiguousBytes):
-          return try contiguousBytes.withUnsafeBytes {
-            try body($0.baseAddress!.advanced(by: position))
-          }
+      case .data(let data):
+        return try data.withUnsafeBytes {
+          try body($0.baseAddress!.advanced(by: position))
+        }
+      case .bytes(let contiguousBytes):
+        return try contiguousBytes.withUnsafeBytes {
+          try body($0.baseAddress!.advanced(by: position))
+        }
       #endif
       case .array(let array):
         return try array.withUnsafeBytes {
@@ -197,7 +197,7 @@ public struct ByteBuffer {
       blob: .byteBuffer(byteBuffer),
       capacity: byteBuffer.capacity)
     _readerIndex = Int(byteBuffer.size)
-    self.capacity = byteBuffer.capacity
+    capacity = byteBuffer.capacity
   }
 
   /// Constructor that creates a Flatbuffer from unsafe memory region by copying
@@ -209,8 +209,8 @@ public struct ByteBuffer {
   @inline(__always)
   public init(
     copyingMemoryBound memory: UnsafeRawPointer,
-    capacity: Int
-  ) {
+    capacity: Int)
+  {
     _storage = Storage(count: capacity)
     _storage.copy(from: memory, count: capacity)
     _readerIndex = capacity
@@ -228,29 +228,29 @@ public struct ByteBuffer {
   }
 
   #if !os(WASI)
-    /// Constructor that creates a Flatbuffer from the Swift Data type object
-    /// - Parameter
-    ///   - data: Swift data Object
-    @inline(__always)
-    public init(data: Data) {
-      _storage = Storage(blob: .data(data), capacity: data.count)
-      _readerIndex = data.count
-      capacity = data.count
-    }
+  /// Constructor that creates a Flatbuffer from the Swift Data type object
+  /// - Parameter
+  ///   - data: Swift data Object
+  @inline(__always)
+  public init(data: Data) {
+    _storage = Storage(blob: .data(data), capacity: data.count)
+    _readerIndex = data.count
+    capacity = data.count
+  }
 
-    /// Constructor that creates a Flatbuffer object from a ContiguousBytes
-    /// - Parameters:
-    ///   - contiguousBytes: Binary stripe to use as the buffer
-    ///   - count: amount of readable bytes
-    @inline(__always)
-    public init<Bytes: ContiguousBytes>(
-      contiguousBytes: Bytes,
-      count: Int
-    ) {
-      _storage = Storage(blob: .bytes(contiguousBytes), capacity: count)
-      _readerIndex = count
-      self.capacity = count
-    }
+  /// Constructor that creates a Flatbuffer object from a ContiguousBytes
+  /// - Parameters:
+  ///   - contiguousBytes: Binary stripe to use as the buffer
+  ///   - count: amount of readable bytes
+  @inline(__always)
+  public init<Bytes: ContiguousBytes>(
+    contiguousBytes: Bytes,
+    count: Int)
+  {
+    _storage = Storage(blob: .bytes(contiguousBytes), capacity: count)
+    _readerIndex = count
+    capacity = count
+  }
   #endif
 
   /// Constructor that creates a Flatbuffer from unsafe memory region without copying
@@ -262,8 +262,8 @@ public struct ByteBuffer {
   @inline(__always)
   public init(
     assumingMemoryBound memory: UnsafeMutableRawPointer,
-    capacity: Int
-  ) {
+    capacity: Int)
+  {
     _storage = Storage(
       blob: .pointer(memory),
       capacity: capacity)
@@ -280,8 +280,8 @@ public struct ByteBuffer {
   init(
     blob: Storage.Blob,
     count: Int,
-    removing removeBytes: Int
-  ) {
+    removing removeBytes: Int)
+  {
     _storage = Storage(blob: blob, capacity: count)
     _readerIndex = removeBytes
     capacity = count
@@ -332,8 +332,8 @@ public struct ByteBuffer {
   @inline(__always)
   public func readSlice<T>(
     index: Int,
-    count: Int
-  ) -> [T] {
+    count: Int) -> [T]
+  {
     assert(
       index + count <= capacity,
       "Reading out of bounds is illegal")
@@ -355,8 +355,8 @@ public struct ByteBuffer {
   public func withUnsafePointerToSlice<T>(
     index: Int,
     count: Int,
-    body: (UnsafeRawBufferPointer) throws -> T
-  ) rethrows -> T {
+    body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T
+  {
     assert(
       index + count <= capacity,
       "Reading out of bounds is illegal")
@@ -366,46 +366,46 @@ public struct ByteBuffer {
   }
 
   #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? {
-      assert(
-        index + count <= capacity,
-        "Reading out of bounds is illegal")
-      return _storage.readWithUnsafeRawPointer(position: index) {
-        let buf = UnsafeBufferPointer(
-          start: $0.bindMemory(to: UInt8.self, capacity: count),
-          count: count)
-        return String(
-          bytes: buf,
-          encoding: type)
-      }
+  /// 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?
+  {
+    assert(
+      index + count <= capacity,
+      "Reading out of bounds is illegal")
+    return _storage.readWithUnsafeRawPointer(position: index) {
+      let buf = UnsafeBufferPointer(
+        start: $0.bindMemory(to: UInt8.self, capacity: count),
+        count: count)
+      return String(
+        bytes: buf,
+        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
-    ///   - count: length of the string
-    @inline(__always)
-    public func readString(
-      at index: Int,
-      count: Int
-    ) -> String? {
-      assert(
-        index + count <= capacity,
-        "Reading out of bounds is illegal")
-      return _storage.readWithUnsafeRawPointer(position: index) {
-        String(cString: $0.bindMemory(to: UInt8.self, capacity: count))
-      }
+  /// 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
+  @inline(__always)
+  public func readString(
+    at index: Int,
+    count: Int) -> String?
+  {
+    assert(
+      index + count <= capacity,
+      "Reading out of bounds is illegal")
+    return _storage.readWithUnsafeRawPointer(position: index) {
+      String(cString: $0.bindMemory(to: UInt8.self, capacity: count))
     }
+  }
   #endif
 
   /// Creates a new Flatbuffer object that's duplicated from the current one
@@ -437,8 +437,8 @@ public struct ByteBuffer {
   @inline(__always)
   public func withUnsafeBytes<T>(
     body: (UnsafeRawBufferPointer) throws
-      -> T
-  ) rethrows -> T {
+      -> T) rethrows -> T
+  {
     try _storage.withUnsafeBytes(body)
   }
 
@@ -446,8 +446,8 @@ public struct ByteBuffer {
   @inline(__always)
   func withUnsafeMutableRawPointer<T>(
     body: (UnsafeMutableRawPointer) throws
-      -> T
-  ) rethrows -> T {
+      -> T) rethrows -> T
+  {
     try _storage.withUnsafeRawPointer(body)
   }
 
@@ -455,8 +455,8 @@ public struct ByteBuffer {
   @inline(__always)
   func readWithUnsafeRawPointer<T>(
     position: Int,
-    _ body: (UnsafeRawPointer) throws -> T
-  ) rethrows -> T {
+    _ body: (UnsafeRawPointer) throws -> T) rethrows -> T
+  {
     try _storage.readWithUnsafeRawPointer(position: position, body)
   }
 }