Adds windows swift support (#8622)

Adding support for windows requires the code generations
to add a compiler statement to completely ignore GRPC code
generation on windows

Cleanup the project to use the main Package.swift to run tests
instead of having it separate and includes the imports for GRPC
within it.

Adds windows swift ci

tests/swift/Tests/Flatbuffers/ByteBufferTests.swift

@@ -0,0 +1,131 @@
+/*
+ * 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 XCTest
+@testable import FlatBuffers
+
+final class ByteBufferTests: XCTestCase {
+  func testCopyingMemory() {
+    let count = 100
+    let ptr = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1)
+    let byteBuffer = ByteBuffer(copyingMemoryBound: ptr, capacity: count)
+    byteBuffer.withUnsafeBytes { memory in
+      XCTAssertNotEqual(memory.baseAddress, ptr)
+    }
+  }
+
+  func testSamePointer() {
+    let count = 100
+    let ptr = UnsafeMutableRawPointer.allocate(byteCount: count, alignment: 1)
+    let byteBuffer = ByteBuffer(assumingMemoryBound: ptr, capacity: count)
+    byteBuffer.withUnsafeBytes { memory in
+      XCTAssertEqual(memory.baseAddress!, ptr)
+    }
+  }
+
+  func testSameDataPtr() {
+    let count = 100
+    let ptr = Data(repeating: 0, count: count)
+    let byteBuffer = ByteBuffer(data: ptr)
+    byteBuffer.withUnsafeBytes { memory in
+      ptr.withUnsafeBytes { ptr in
+        XCTAssertEqual(memory.baseAddress!, ptr)
+      }
+    }
+  }
+
+  func testSameArrayPtr() {
+    let count = 100
+    let ptr: [UInt8] = Array(repeating: 0, count: count)
+    let byteBuffer = ByteBuffer(bytes: ptr)
+    ptr.withUnsafeBytes { ptr in
+      byteBuffer.withUnsafeBytes { memory in
+        XCTAssertEqual(memory.baseAddress, ptr.baseAddress)
+      }
+    }
+  }
+
+  func testReadingDoubleBuffer() {
+    let count = 8
+    let array: [Double] = Array(repeating: 8.8, count: count)
+    var oldBuffer = _InternalByteBuffer(initialSize: 16)
+    oldBuffer.push(elements: array)
+    let bytes: [Byte] = oldBuffer.withUnsafeBytes { bytes in
+      Array(bytes)
+    }
+    let byteBuffer = ByteBuffer(bytes: bytes)
+    byteBuffer.withUnsafePointerToSlice(index: 0, count: count) { ptr in
+      XCTAssertEqual(ptr.count, count)
+      bytes.withUnsafeBufferPointer {
+        XCTAssertEqual(
+          UnsafeRawPointer($0.baseAddress),
+          UnsafeRawPointer(ptr.baseAddress))
+      }
+    }
+  }
+
+  func testReadingNativeStructs() {
+    let array = [
+      MyGame_Example_Vec3(
+        x: 3.2,
+        y: 3.2,
+        z: 3.2,
+        test1: 8,
+        test2: .red,
+        test3: MyGame_Example_Test(a: 8, b: 8)),
+      MyGame_Example_Vec3(
+        x: 3.2,
+        y: 3.2,
+        z: 3.2,
+        test1: 8,
+        test2: .green,
+        test3: MyGame_Example_Test(a: 16, b: 16)),
+      MyGame_Example_Vec3(
+        x: 3.2,
+        y: 3.2,
+        z: 3.2,
+        test1: 8,
+        test2: .blue,
+        test3: MyGame_Example_Test(a: 32, b: 32)),
+    ]
+    let count = array.count
+    var oldBuffer = _InternalByteBuffer(initialSize: 16)
+    oldBuffer.push(elements: array)
+    let bytes: [Byte] = oldBuffer.withUnsafeBytes { bytes in
+      Array(bytes)
+    }
+    let byteBuffer = ByteBuffer(bytes: bytes)
+    byteBuffer
+      .withUnsafePointerToSlice(index: 0, count: count) { bufferPointer in
+        XCTAssertEqual(bufferPointer.count, count)
+        bytes.withUnsafeBufferPointer { ptr in
+          XCTAssertEqual(
+            UnsafeRawPointer(ptr.baseAddress),
+            UnsafeRawPointer(bufferPointer.baseAddress))
+        }
+      }
+  }
+}
+
+private struct TestNativeStructs: NativeStruct {
+  let x: Double
+  let y: Double
+  let z: Int
+}
+
+extension MyGame_Example_Color: CaseIterable {
+  public static var allCases: [MyGame_Example_Color] = [.red, .blue, .green]
+}

tests/swift/Tests/Flatbuffers/FlatBuffersMonsterWriterTests.swift

@@ -0,0 +1,563 @@
+/*
+ * 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
+import XCTest
+@testable import FlatBuffers
+
+typealias Test = MyGame_Example_Test
+typealias Monster = MyGame_Example_Monster
+typealias Vec3 = MyGame_Example_Vec3
+typealias Stat = MyGame_Example_Stat
+
+class FlatBuffersMonsterWriterTests: XCTestCase {
+
+  func testData() {
+    // swiftformat:disable all
+    let data = Data([48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+    // swiftformat:enable all
+    let _data = ByteBuffer(data: data)
+    readVerifiedMonster(fb: _data)
+  }
+
+  func testReadFromOtherLanguages() {
+    let url = URL(fileURLWithPath: path, isDirectory: true)
+      .appendingPathComponent("monsterdata_test")
+      .appendingPathExtension("mon")
+    let data = try! Data(contentsOf: url)
+    let _data = ByteBuffer(data: data)
+
+    readVerifiedMonster(fb: _data)
+  }
+
+  func testCreateMonster() {
+    let bytes = createMonster(withPrefix: false)
+    // swiftformat:disable all
+    XCTAssertEqual(bytes.sizedByteArray, [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+    // swiftformat:enable all
+    var buffer = bytes.buffer
+
+    let monster: MyGame_Example_Monster = getRoot(byteBuffer: &buffer)
+    readMonster(monster: monster)
+    mutateMonster(fb: bytes.buffer)
+    readMonster(monster: monster)
+  }
+
+  func testCreateMonsterResizedBuffer() {
+    let bytes = createMonster(withPrefix: false)
+    // swiftformat:disable all
+    XCTAssertEqual(bytes.sizedByteArray, [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+    // swiftformat:enable all
+    readVerifiedMonster(fb: bytes.sizedBuffer)
+  }
+
+  func testCreateMonsterPrefixed() {
+    let bytes = createMonster(withPrefix: true)
+    // swiftformat:disable all
+    XCTAssertEqual(bytes.sizedByteArray, [44, 1, 0, 0, 44, 0, 0, 0, 77, 79, 78, 83, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+    // swiftformat:enable all
+
+    var buffer = bytes.buffer
+    readMonster(monster: getPrefixedSizeRoot(byteBuffer: &buffer))
+  }
+
+  func testCreateMonsterUsingCreateMonsterMethodWithNilPos() {
+    var fbb = FlatBufferBuilder(initialSize: 1)
+    let name = fbb.create(string: "Frodo")
+    let mStart = Monster.startMonster(&fbb)
+    Monster.add(name: name, &fbb)
+    let root = Monster.endMonster(&fbb, start: mStart)
+    fbb.finish(offset: root)
+    var buffer = fbb.sizedBuffer
+    let newMonster: Monster = getRoot(byteBuffer: &buffer)
+    XCTAssertNil(newMonster.pos)
+    XCTAssertEqual(newMonster.name, "Frodo")
+  }
+
+  func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
+    var fbb = FlatBufferBuilder(initialSize: 1)
+    let name = fbb.create(string: "Barney")
+    let mStart = Monster.startMonster(&fbb)
+    Monster.add(
+      pos: MyGame_Example_Vec3(
+        x: 10,
+        y: 0,
+        z: 0,
+        test1: 0,
+        test2: .blue,
+        test3: .init()),
+      &fbb)
+    Monster.add(name: name, &fbb)
+    let root = Monster.endMonster(&fbb, start: mStart)
+    fbb.finish(offset: root)
+
+    var buffer = fbb.sizedBuffer
+    let newMonster: Monster = getRoot(byteBuffer: &buffer)
+    XCTAssertEqual(newMonster.pos!.x, 10)
+    XCTAssertEqual(newMonster.name, "Barney")
+  }
+
+  func testReadMonsterFromUnsafePointerWithoutCopying() {
+    // swiftformat:disable all
+    var array: [UInt8] = [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]
+    // swiftformat:enable all
+    let unpacked = array
+      .withUnsafeMutableBytes { memory -> MyGame_Example_MonsterT in
+        var bytes = ByteBuffer(
+          assumingMemoryBound: memory.baseAddress!,
+          capacity: memory.count)
+        var monster: Monster = getRoot(byteBuffer: &bytes)
+        readFlatbufferMonster(monster: &monster)
+        let unpacked = monster.unpack()
+        return unpacked
+      }
+    readObjectApi(monster: unpacked)
+  }
+
+  func testArrayOfBools() {
+    let boolArray = [false, true, false, true, false, true, false]
+    var fbb = FlatBufferBuilder(initialSize: 1)
+    let name = fbb.create(string: "Frodo")
+    let bools = fbb.createVector(boolArray)
+
+    let root = Monster.createMonster(
+      &fbb,
+      nameOffset: name,
+      testarrayofboolsVectorOffset: bools)
+    fbb.finish(offset: root)
+    var buffer = fbb.sizedBuffer
+    let monster: Monster = getRoot(byteBuffer: &buffer)
+    let values = monster.testarrayofbools
+
+    XCTAssertEqual(boolArray, values)
+
+    for i in 0..<monster.testarrayofboolsCount {
+      XCTAssertEqual(boolArray[Int(i)], monster.testarrayofbools(at: i))
+    }
+  }
+
+  func readVerifiedMonster(fb: ByteBuffer) {
+    var byteBuffer = fb
+    XCTAssertNoThrow(
+      try readMonster(
+        monster: getCheckedRoot(
+          byteBuffer: &byteBuffer) as MyGame_Example_Monster))
+  }
+
+  func testUnalignedRead() {
+    // Aligned read
+    let fbb = createMonster(withPrefix: false)
+    let testAligned: () -> Bool = {
+      var buffer = fbb.sizedBuffer
+      var monster: Monster = getRoot(byteBuffer: &buffer)
+      self.readFlatbufferMonster(monster: &monster)
+      return true
+    }
+    XCTAssertEqual(testAligned(), true)
+    let testUnaligned: () -> Bool = {
+      var bytes: [UInt8] = [0x00]
+      bytes.append(contentsOf: fbb.sizedByteArray)
+      return bytes.withUnsafeMutableBytes { ptr in
+        guard var baseAddress = ptr.baseAddress else {
+          XCTFail("Base pointer is not defined")
+          return false
+        }
+        baseAddress = baseAddress.advanced(by: 1)
+        let unlignedPtr = UnsafeMutableRawPointer(baseAddress)
+        var bytes = ByteBuffer(
+          assumingMemoryBound: unlignedPtr,
+          capacity: ptr.count - 1)
+        var monster: Monster = getRoot(byteBuffer: &bytes)
+        self.readFlatbufferMonster(monster: &monster)
+        return true
+      }
+    }
+    XCTAssertEqual(testUnaligned(), true)
+  }
+
+  func testReadingRemovedSizeUnalignedBuffer() {
+    // Aligned read
+    let fbb = createMonster(withPrefix: true)
+    let testUnaligned: () -> Bool = {
+      var bytes: [UInt8] = [0x00]
+      bytes.append(contentsOf: fbb.sizedByteArray)
+      return bytes.withUnsafeMutableBytes { ptr in
+        guard var baseAddress = ptr.baseAddress else {
+          XCTFail("Base pointer is not defined")
+          return false
+        }
+        baseAddress = baseAddress.advanced(by: 1)
+        let unlignedPtr = UnsafeMutableRawPointer(baseAddress)
+        let bytes = ByteBuffer(
+          assumingMemoryBound: unlignedPtr,
+          capacity: ptr.count - 1)
+        var newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes)
+        var monster: Monster = getRoot(byteBuffer: &newBuf)
+        self.readFlatbufferMonster(monster: &monster)
+        return true
+      }
+    }
+    XCTAssertEqual(testUnaligned(), true)
+  }
+
+  func testCreateMessage() {
+    let fbb = createMonster(withPrefix: false)
+    let byteBuffer = fbb.buffer
+    let firstMessage = Message<Monster>(byteBuffer: byteBuffer)
+    firstMessage.withUnsafeReadableBytes { ptr in
+      var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count)
+      var monster: Monster = getRoot(byteBuffer: &bytes)
+      self.readFlatbufferMonster(monster: &monster)
+    }
+
+    let secondByteBuffer = fbb.sizedBuffer
+    let secondMessage = Message<Monster>(byteBuffer: secondByteBuffer)
+    secondMessage.withUnsafeReadableBytes { ptr in
+      var bytes = ByteBuffer(contiguousBytes: ptr, count: ptr.count)
+      var monster: Monster = getRoot(byteBuffer: &bytes)
+      self.readFlatbufferMonster(monster: &monster)
+    }
+  }
+
+  func testForceRetainedObject() {
+    let byteBuffer = {
+      // swiftformat:disable all
+      var data: Data? = Data([48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+      // swiftformat:enable all
+      let buffer = ByteBuffer(data: data!)
+      data = nil
+      return buffer
+    }()
+    readVerifiedMonster(fb: byteBuffer)
+  }
+
+  func readMonster(monster: Monster) {
+    var monster = monster
+    readFlatbufferMonster(monster: &monster)
+    let unpacked: MyGame_Example_MonsterT? = monster.unpack()
+    readObjectApi(monster: unpacked!)
+    guard var buffer = unpacked?.serialize()
+    else { fatalError("Couldnt generate bytebuffer") }
+    var newMonster: Monster = getRoot(byteBuffer: &buffer)
+    readFlatbufferMonster(monster: &newMonster)
+  }
+
+  func createMonster(withPrefix prefix: Bool) -> FlatBufferBuilder {
+    var fbb = FlatBufferBuilder(initialSize: 1)
+    let names = [
+      fbb.create(string: "Frodo"),
+      fbb.create(string: "Barney"),
+      fbb.create(string: "Wilma"),
+    ]
+    var offsets: [Offset] = []
+    let start1 = Monster.startMonster(&fbb)
+    Monster.add(name: names[0], &fbb)
+    offsets.append(Monster.endMonster(&fbb, start: start1))
+    let start2 = Monster.startMonster(&fbb)
+    Monster.add(name: names[1], &fbb)
+    offsets.append(Monster.endMonster(&fbb, start: start2))
+    let start3 = Monster.startMonster(&fbb)
+    Monster.add(name: names[2], &fbb)
+    offsets.append(Monster.endMonster(&fbb, start: start3))
+
+    let sortedArray = Monster.sortVectorOfMonster(offsets: offsets, &fbb)
+
+    let str = fbb.create(string: "MyMonster")
+    let test1 = fbb.create(string: "test1")
+    let test2 = fbb.create(string: "test2")
+    let _inv: [Byte] = [0, 1, 2, 3, 4]
+    let inv = fbb.createVector(_inv)
+
+    let fred = fbb.create(string: "Fred")
+    let mon1Start = Monster.startMonster(&fbb)
+    Monster.add(name: fred, &fbb)
+    let mon2 = Monster.endMonster(&fbb, start: mon1Start)
+
+    let test4 = fbb.createVector(ofStructs: [
+      MyGame_Example_Test(a: 30, b: 40),
+      MyGame_Example_Test(a: 10, b: 20),
+    ])
+
+    let stringTestVector = fbb.createVector(ofOffsets: [test1, test2])
+    let mStart = Monster.startMonster(&fbb)
+    Monster.add(
+      pos: MyGame_Example_Vec3(
+        x: 1,
+        y: 2,
+        z: 3,
+        test1: 3,
+        test2: .green,
+        test3: .init(a: 5, b: 6)),
+      &fbb)
+    Monster.add(hp: 80, &fbb)
+    Monster.add(name: str, &fbb)
+    Monster.addVectorOf(inventory: inv, &fbb)
+    Monster.add(testType: .monster, &fbb)
+    Monster.add(test: mon2, &fbb)
+    Monster.addVectorOf(test4: test4, &fbb)
+    Monster.addVectorOf(testarrayofstring: stringTestVector, &fbb)
+    Monster.add(testbool: true, &fbb)
+    Monster.addVectorOf(testarrayoftables: sortedArray, &fbb)
+    let end = Monster.endMonster(&fbb, start: mStart)
+    Monster.finish(&fbb, end: end, prefix: prefix)
+    return fbb
+  }
+
+  func mutateMonster(fb: ByteBuffer) {
+    var fb = fb
+
+    let monster: Monster = getRoot(byteBuffer: &fb)
+    XCTAssertFalse(monster.mutate(mana: 10))
+    XCTAssertEqual(monster.testarrayoftables(at: 0)?.name, "Barney")
+    XCTAssertEqual(monster.testarrayoftables(at: 1)?.name, "Frodo")
+    XCTAssertEqual(monster.testarrayoftables(at: 2)?.name, "Wilma")
+
+    // Example of searching for a table by the key
+    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Frodo"))
+    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Barney"))
+    XCTAssertNotNil(monster.testarrayoftablesBy(key: "Wilma"))
+
+    XCTAssertEqual(monster.testType, .monster)
+
+    XCTAssertEqual(monster.mutate(inventory: 1, at: 0), true)
+    XCTAssertEqual(monster.mutate(inventory: 2, at: 1), true)
+    XCTAssertEqual(monster.mutate(inventory: 3, at: 2), true)
+    XCTAssertEqual(monster.mutate(inventory: 4, at: 3), true)
+    XCTAssertEqual(monster.mutate(inventory: 5, at: 4), true)
+
+    for i in 0..<monster.inventoryCount {
+      XCTAssertEqual(monster.inventory(at: i), Byte(i + 1))
+    }
+
+    XCTAssertEqual(monster.mutate(inventory: 0, at: 0), true)
+    XCTAssertEqual(monster.mutate(inventory: 1, at: 1), true)
+    XCTAssertEqual(monster.mutate(inventory: 2, at: 2), true)
+    XCTAssertEqual(monster.mutate(inventory: 3, at: 3), true)
+    XCTAssertEqual(monster.mutate(inventory: 4, at: 4), true)
+
+    let vec = monster.mutablePos
+    XCTAssertEqual(vec?.x, 1)
+    XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)
+    XCTAssertTrue(vec?.mutate(test1: 55) ?? false)
+    XCTAssertEqual(vec?.x, 55.0)
+    XCTAssertEqual(vec?.test1, 55.0)
+    XCTAssertTrue(vec?.mutate(x: 1) ?? false)
+    XCTAssertEqual(vec?.x, 1)
+    XCTAssertTrue(vec?.mutate(test1: 3) ?? false)
+  }
+
+  func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
+    XCTAssertEqual(monster.hp, 80)
+    XCTAssertEqual(monster.mana, 150)
+    XCTAssertEqual(monster.name, "MyMonster")
+    let pos = monster.pos
+    XCTAssertEqual(pos?.x, 1)
+    XCTAssertEqual(pos?.y, 2)
+    XCTAssertEqual(pos?.z, 3)
+    XCTAssertEqual(pos?.test1, 3)
+    XCTAssertEqual(pos?.test2, .green)
+    let test = pos?.test3
+    XCTAssertEqual(test?.a, 5)
+    XCTAssertEqual(test?.b, 6)
+    XCTAssertEqual(monster.testType, .monster)
+    let monster2 = monster.test(type: Monster.self)
+    XCTAssertEqual(monster2?.name, "Fred")
+
+    XCTAssertEqual(monster.mutate(mana: 10), false)
+
+    XCTAssertEqual(monster.mana, 150)
+    XCTAssertEqual(monster.inventoryCount, 5)
+    var sum: Byte = 0
+    for i in 0...monster.inventoryCount {
+      sum += monster.inventory(at: i)
+    }
+    XCTAssertEqual(sum, 10)
+
+    monster.withUnsafePointerToInventory { ptr in
+      var sum: UInt8 = 0
+      for pointee in ptr.startIndex..<ptr.endIndex {
+        sum += ptr[pointee]
+      }
+      XCTAssertEqual(sum, 10)
+    }
+
+    XCTAssertEqual(monster.test4Count, 2)
+
+    let test0 = monster.test4(at: 0)
+    let test1 = monster.test4(at: 1)
+    var sum0 = 0
+    var sum1 = 0
+    if let a = test0?.a, let b = test0?.b {
+      sum0 = Int(a) + Int(b)
+    }
+    if let a = test1?.a, let b = test1?.b {
+      sum1 = Int(a) + Int(b)
+    }
+    XCTAssertEqual(sum0 + sum1, 100)
+
+    monster.withUnsafePointerToTest4 { ptr in
+      guard let ptr = ptr.baseAddress else { return }
+
+      let bindedMemory: UnsafeBufferPointer<MyGame_Example_Test> =
+        UnsafeBufferPointer(
+          start: ptr.bindMemory(
+            to: MyGame_Example_Test.self,
+            capacity: Int(monster.test4Count)),
+          count: Int(monster.test4Count))
+      var pointerSum = 0
+      for pointee in bindedMemory.startIndex..<bindedMemory.endIndex {
+        pointerSum += Int(bindedMemory[pointee].a) +
+          Int(bindedMemory[pointee].b)
+      }
+      XCTAssertEqual(pointerSum, 100)
+    }
+
+    let mutableTest0 = monster.mutableTest4(at: 0)
+    let mutableTest1 = monster.mutableTest4(at: 1)
+    var sum2 = 0
+    var sum3 = 0
+    if let a = mutableTest0?.a, let b = mutableTest0?.b {
+      sum2 = Int(a) + Int(b)
+    }
+    if let a = mutableTest1?.a, let b = mutableTest1?.b {
+      sum3 = Int(a) + Int(b)
+    }
+    XCTAssertEqual(sum2 + sum3, 100)
+
+    XCTAssertEqual(monster.testarrayofstringCount, 2)
+    XCTAssertEqual(monster.testarrayofstring(at: 0), "test1")
+    XCTAssertEqual(monster.testarrayofstring(at: 1), "test2")
+    XCTAssertEqual(monster.testbool, true)
+
+    let array = monster.nameSegmentArray
+    XCTAssertEqual(String(bytes: array ?? [], encoding: .utf8), "MyMonster")
+
+    if 0 == monster.testarrayofboolsCount  {
+      XCTAssertEqual(monster.testarrayofbools.isEmpty, true)
+    } else {
+      XCTAssertEqual(monster.testarrayofbools.isEmpty, false)
+    }
+  }
+
+  func readObjectApi(monster: MyGame_Example_MonsterT) {
+    XCTAssertEqual(monster.hp, 80)
+    XCTAssertEqual(monster.mana, 150)
+    XCTAssertEqual(monster.name, "MyMonster")
+    let pos = monster.pos
+    XCTAssertEqual(pos?.x, 1)
+    XCTAssertEqual(pos?.y, 2)
+    XCTAssertEqual(pos?.z, 3)
+    XCTAssertEqual(pos?.test1, 3)
+    XCTAssertEqual(pos?.test2, .green)
+    let test = pos?.test3
+    XCTAssertEqual(test?.a, 5)
+    XCTAssertEqual(test?.b, 6)
+    let monster2 = monster.test?.value as? MyGame_Example_MonsterT
+    XCTAssertEqual(monster2?.name, "Fred")
+    XCTAssertEqual(monster.mana, 150)
+    monster.mana = 10
+    XCTAssertEqual(monster.mana, 10)
+    monster.mana = 150
+    XCTAssertEqual(monster.mana, 150)
+
+    XCTAssertEqual(monster.inventory.count, 5)
+    var sum: Byte = 0
+    for i in monster.inventory {
+      sum += i
+    }
+    XCTAssertEqual(sum, 10)
+    XCTAssertEqual(monster.test4.count, 2)
+    let test0 = monster.test4[0]
+    let test1 = monster.test4[1]
+    var sum0 = 0
+    var sum1 = 0
+    if let a = test0?.a, let b = test0?.b {
+      sum0 = Int(a) + Int(b)
+    }
+    if let a = test1?.a, let b = test1?.b {
+      sum1 = Int(a) + Int(b)
+    }
+    XCTAssertEqual(sum0 + sum1, 100)
+    XCTAssertEqual(monster.testbool, true)
+  }
+
+  func testEncoding() {
+    let fbb = createMonster(withPrefix: false)
+    var sizedBuffer = fbb.sizedBuffer
+    do {
+      struct Test: Decodable {
+        struct Pos: Decodable {
+          let x, y, z: Int
+        }
+        let hp: Int
+        let inventory: [UInt8]
+        let name: String
+        let pos: Pos
+      }
+      let reader: Monster = try getCheckedRoot(byteBuffer: &sizedBuffer)
+      let encoder = JSONEncoder()
+      encoder.keyEncodingStrategy = .convertToSnakeCase
+      let data = try encoder.encode(reader)
+      let decoder = JSONDecoder()
+      decoder.keyDecodingStrategy = .convertFromSnakeCase
+      let value = try decoder.decode(Test.self, from: data)
+      XCTAssertEqual(value.name, "MyMonster")
+      XCTAssertEqual(value.pos.x, 1)
+      XCTAssertEqual(value.pos.y, 2)
+      XCTAssertEqual(value.pos.z, 3)
+    } catch {
+      XCTFail(error.localizedDescription)
+    }
+  }
+
+  var jsonData: String {
+    """
+    {\"hp\":80,\"inventory\":[0,1,2,3,4],\"test\":{\"name\":\"Fred\"},\"testarrayofstring\":[\"test1\",\"test2\"],\"testarrayoftables\":[{\"name\":\"Barney\"},{\"name\":\"Frodo\"},{\"name\":\"Wilma\"}],\"test4\":[{\"a\":30,\"b\":40},{\"a\":10,\"b\":20}],\"testbool\":true,\"test_type\":\"Monster\",\"pos\":{\"y\":2,\"test3\":{\"a\":5,\"b\":6},\"z\":3,\"x\":1,\"test1\":3,\"test2\":\"Green\"},\"name\":\"MyMonster\"}
+    """
+  }
+
+  private var path: String {
+    #if os(macOS)
+    // Gets the current path of this test file then
+    // strips out the nested directories.
+    let filePath = URL(filePath: #file)
+      .deletingLastPathComponent()
+    return filePath.absoluteString
+    #else
+    return FileManager.default.currentDirectoryPath
+      .appending("/tests/swift/Tests/Flatbuffers")
+    #endif
+  }
+
+  func testContiguousBytes() {
+    let byteArray: [UInt8] = [3, 1, 4, 1, 5, 9]
+    var fbb = FlatBufferBuilder(initialSize: 1)
+    let name = fbb.create(string: "Frodo")
+    let bytes = fbb.createVector(bytes: byteArray)
+    let root = Monster.createMonster(
+      &fbb,
+      nameOffset: name,
+      inventoryVectorOffset: bytes)
+    fbb.finish(offset: root)
+    var buffer = fbb.sizedBuffer
+    let monster: Monster = getRoot(byteBuffer: &buffer)
+    let values = monster.inventory
+
+    monster.withUnsafePointerToInventory {
+      XCTAssertEqual(Array($0), values)
+    }
+  }
+}

tests/swift/Tests/Flatbuffers/FlatBuffersNanInfTests.swift

@@ -0,0 +1,83 @@
+/*
+ * 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 XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersNanInfTests: XCTestCase {
+
+  func createTestTable() -> FlatBufferBuilder {
+    var fbb = FlatBufferBuilder()
+    let msg = Swift_Tests_NanInfTable.createNanInfTable(
+      &fbb,
+      valueNan: .nan,
+      valueInf: .infinity,
+      valueNinf: -.infinity,
+      value: 100.0)
+    fbb.finish(offset: msg)
+    return fbb
+  }
+
+  func testInfNanBinary() {
+    let fbb = createTestTable()
+    let data = fbb.sizedByteArray
+
+    var buffer = ByteBuffer(bytes: data)
+    let table: Swift_Tests_NanInfTable = getRoot(byteBuffer: &buffer)
+    XCTAssert(table.defaultNan.isNaN)
+    XCTAssertEqual(table.defaultInf, .infinity)
+    XCTAssertEqual(table.defaultNinf, -.infinity)
+    XCTAssert(table.valueNan.isNaN)
+    XCTAssertEqual(table.valueInf, .infinity)
+    XCTAssertEqual(table.valueNinf, -.infinity)
+    XCTAssertEqual(table.value, 100.0)
+  }
+
+  func testInfNanJSON() {
+    let fbb = createTestTable()
+    var bb = fbb.sizedBuffer
+    do {
+      struct Test: Decodable {
+        let valueInf: Double
+        let value: Int
+        let valueNan: Double
+        let valueNinf: Double
+      }
+      let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb)
+      let encoder = JSONEncoder()
+      encoder.keyEncodingStrategy = .convertToSnakeCase
+      encoder.nonConformingFloatEncodingStrategy =
+        .convertToString(
+          positiveInfinity: "inf",
+          negativeInfinity: "-inf",
+          nan: "nan")
+      let data = try encoder.encode(reader)
+      let decoder = JSONDecoder()
+      decoder.nonConformingFloatDecodingStrategy = .convertFromString(
+        positiveInfinity: "inf",
+        negativeInfinity: "-inf",
+        nan: "nan")
+      decoder.keyDecodingStrategy = .convertFromSnakeCase
+      let value = try decoder.decode(Test.self, from: data)
+      XCTAssertEqual(value.value, 100)
+      XCTAssertEqual(value.valueInf, .infinity)
+      XCTAssertEqual(value.valueNinf, -.infinity)
+    } catch {
+      XCTFail(error.localizedDescription)
+    }
+  }
+
+}

tests/swift/Tests/Flatbuffers/FlatBuffersStructsTests.swift

@@ -0,0 +1,45 @@
+/*
+ * 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 XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersStructsTests: XCTestCase {
+
+  func testWritingAndMutatingBools() {
+    var fbb = FlatBufferBuilder()
+    let start = TestMutatingBool.startTestMutatingBool(&fbb)
+    TestMutatingBool.add(b: Property(property: false), &fbb)
+    let root = TestMutatingBool.endTestMutatingBool(&fbb, start: start)
+    fbb.finish(offset: root)
+
+    var buffer = fbb.sizedBuffer
+    let testMutatingBool: TestMutatingBool = getRoot(byteBuffer: &buffer)
+    let property = testMutatingBool.mutableB
+    XCTAssertEqual(property?.property, false)
+    property?.mutate(property: false)
+    XCTAssertEqual(property?.property, false)
+    property?.mutate(property: true)
+    XCTAssertEqual(property?.property, true)
+  }
+
+}
+
+struct Vec: NativeStruct {
+  var x: Float32
+  var y: Float32
+  var z: Float32
+}

tests/swift/Tests/Flatbuffers/FlatBuffersTests.swift

@@ -0,0 +1,206 @@
+/*
+ * 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 XCTest
+@testable import Common
+@testable import FlatBuffers
+
+final class FlatBuffersTests: XCTestCase {
+
+  let country = "Norway"
+
+  func testEndian() { XCTAssertEqual(isLitteEndian, true) }
+
+  func testOffset() {
+    let o = Offset()
+    let b = Offset(offset: 1)
+    XCTAssertEqual(o.isEmpty, true)
+    XCTAssertEqual(b.isEmpty, false)
+  }
+
+  func testCreateString() {
+    let helloWorld = "Hello, world!"
+    var b = FlatBufferBuilder(initialSize: 16)
+    XCTAssertEqual(b.create(string: country).o, 12)
+    XCTAssertEqual(b.create(string: helloWorld).o, 32)
+    b.clear()
+    XCTAssertEqual(b.create(string: helloWorld).o, 20)
+    XCTAssertEqual(b.create(string: country).o, 32)
+    b.clear()
+    XCTAssertEqual(b.create(string: String(repeating: "a", count: 257)).o, 264)
+  }
+
+  func testStartTable() {
+    var b = FlatBufferBuilder(initialSize: 16)
+    XCTAssertNoThrow(b.startTable(with: 0))
+    b.clear()
+    XCTAssertEqual(b.create(string: country).o, 12)
+    XCTAssertEqual(b.startTable(with: 0), 12)
+  }
+
+  func testCreateFinish() {
+    var b = FlatBufferBuilder(initialSize: 16)
+    let countryOff = Country.createCountry(
+      builder: &b,
+      name: country,
+      log: 200,
+      lan: 100)
+    b.finish(offset: countryOff)
+    // swiftformat:disable all
+    let v: [UInt8] = [16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 12, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+    // swiftformat:enable all
+    XCTAssertEqual(b.sizedByteArray, v)
+  }
+
+  func testCreateFinishWithPrefix() {
+    var b = FlatBufferBuilder(initialSize: 16)
+    let countryOff = Country.createCountry(
+      builder: &b,
+      name: country,
+      log: 200,
+      lan: 100)
+    b.finish(offset: countryOff, addPrefix: true)
+    // swiftformat:disable all
+    let v: [UInt8] = [44, 0, 0, 0, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 12, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+    // swiftformat:enable all
+    XCTAssertEqual(b.sizedByteArray, v)
+  }
+
+  func testReadCountry() {
+    // swiftformat:disable all
+    let v: [UInt8] = [16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 12, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0]
+    // swiftformat:enable all
+    let buffer = ByteBuffer(bytes: v)
+    let c = Country.getRootAsCountry(buffer)
+    XCTAssertEqual(c.lan, 100)
+    XCTAssertEqual(c.log, 200)
+    XCTAssertEqual(c.nameVector, [78, 111, 114, 119, 97, 121])
+    XCTAssertEqual(c.name, country)
+  }
+
+  func testWriteNullableStrings() {
+    var b = FlatBufferBuilder()
+    XCTAssertTrue(b.create(string: nil).isEmpty)
+    XCTAssertTrue(b.createShared(string: nil).isEmpty)
+  }
+
+  func testWriteOptionalValues() {
+    var b = FlatBufferBuilder()
+    let root = optional_scalars_ScalarStuff.createScalarStuff(
+      &b,
+      justI8: 80,
+      maybeI8: nil,
+      justU8: 100,
+      maybeU8: 10,
+      maybeBool: true,
+      justEnum: .one,
+      maybeEnum: nil)
+    b.finish(offset: root)
+    var buffer = b.sizedBuffer
+    let scalarTable: optional_scalars_ScalarStuff = getRoot(byteBuffer: &buffer)
+    XCTAssertEqual(scalarTable.justI8, 80)
+    XCTAssertNil(scalarTable.maybeI8)
+    XCTAssertEqual(scalarTable.maybeBool, true)
+    XCTAssertEqual(scalarTable.defaultI8, 42)
+    XCTAssertEqual(scalarTable.justU8, 100)
+    XCTAssertEqual(scalarTable.maybeU8, 10)
+    XCTAssertEqual(scalarTable.justEnum, .one)
+    XCTAssertNil(scalarTable.maybeEnum)
+  }
+}
+
+class Country {
+
+  static let offsets: (name: VOffset, lan: VOffset, lng: VOffset) = (4, 6, 8)
+  private var __t: Table
+
+  private init(_ t: Table) {
+    __t = t
+  }
+
+  var lan: Int32 { let o = __t.offset(6); return o == 0 ? 0 : __t.readBuffer(
+    of: Int32.self,
+    at: o) }
+  var log: Int32 { let o = __t.offset(8); return o == 0 ? 0 : __t.readBuffer(
+    of: Int32.self,
+    at: o) }
+  var nameVector: [UInt8]? { __t.getVector(at: 4) }
+  var name: String? {
+    let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
+
+  @inlinable
+  static func getRootAsCountry(_ bb: ByteBuffer) -> Country {
+    Country(Table(
+      bb: bb,
+      position: Int32(bb.read(def: UOffset.self, position: 0))))
+  }
+
+  @inlinable
+  static func createCountry(
+    builder: inout FlatBufferBuilder,
+    name: String,
+    log: Int32,
+    lan: Int32) -> Offset
+  {
+    createCountry(
+      builder: &builder,
+      offset: builder.create(string: name),
+      log: log,
+      lan: lan)
+  }
+
+  @inlinable
+  static func createCountry(
+    builder: inout FlatBufferBuilder,
+    offset: Offset,
+    log: Int32,
+    lan: Int32) -> Offset
+  {
+    let _start = builder.startTable(with: 3)
+    Country.add(builder: &builder, lng: log)
+    Country.add(builder: &builder, lan: lan)
+    Country.add(builder: &builder, name: offset)
+    return Country.end(builder: &builder, startOffset: _start)
+  }
+
+  @inlinable
+  static func end(
+    builder: inout FlatBufferBuilder,
+    startOffset: UOffset) -> Offset
+  {
+    Offset(offset: builder.endTable(at: startOffset))
+  }
+
+  @inlinable
+  static func add(builder: inout FlatBufferBuilder, name: String) {
+    add(builder: &builder, name: builder.create(string: name))
+  }
+
+  @inlinable
+  static func add(builder: inout FlatBufferBuilder, name: Offset) {
+    builder.add(offset: name, at: Country.offsets.name)
+  }
+
+  @inlinable
+  static func add(builder: inout FlatBufferBuilder, lan: Int32) {
+    builder.add(element: lan, def: 0, at: Country.offsets.lan)
+  }
+
+  @inlinable
+  static func add(builder: inout FlatBufferBuilder, lng: Int32) {
+    builder.add(element: lng, def: 0, at: Country.offsets.lng)
+  }
+}

tests/swift/Tests/Flatbuffers/FlatBuffersUnionTests.swift

@@ -0,0 +1,430 @@
+/*
+ * 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 XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersUnionTests: XCTestCase {
+
+  func testCreateMonstor() {
+
+    var b = FlatBufferBuilder(initialSize: 20)
+    let dmg: Int16 = 5
+    let str = "Axe"
+    let axe = b.create(string: str)
+    let weapon = Weapon.createWeapon(builder: &b, offset: axe, dmg: dmg)
+    let weapons = b.createVector(ofOffsets: [weapon])
+    let root = LocalMonster.createMonster(
+      builder: &b,
+      offset: weapons,
+      equipment: .Weapon,
+      equippedOffset: weapon.o)
+    b.finish(offset: root)
+    let buffer = b.sizedByteArray
+    // swiftformat:disable all
+    XCTAssertEqual(buffer, [16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 8, 0, 7, 0, 12, 0, 10, 0, 0, 0, 0, 0, 0, 1, 8, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 12, 0, 0, 0, 8, 0, 12, 0, 8, 0, 6, 0, 8, 0, 0, 0, 0, 0, 5, 0, 4, 0, 0, 0, 3, 0, 0, 0, 65, 120, 101, 0])
+    // swiftformat:enable all
+    let monster = LocalMonster.getRootAsMonster(bb: ByteBuffer(bytes: buffer))
+    XCTAssertEqual(monster.weapon(at: 0)?.dmg, dmg)
+    XCTAssertEqual(monster.weapon(at: 0)?.name, str)
+    XCTAssertEqual(monster.weapon(at: 0)?.nameVector, [65, 120, 101])
+    let p: Weapon? = monster.equiped()
+    XCTAssertEqual(p?.dmg, dmg)
+    XCTAssertEqual(p?.name, str)
+    XCTAssertEqual(p?.nameVector, [65, 120, 101])
+  }
+
+  func testEndTableFinish() {
+    var builder = FlatBufferBuilder(initialSize: 20)
+    let sword = builder.create(string: "Sword")
+    let axe = builder.create(string: "Axe")
+    let weaponOne = Weapon.createWeapon(
+      builder: &builder,
+      offset: sword,
+      dmg: 3)
+    let weaponTwo = Weapon.createWeapon(builder: &builder, offset: axe, dmg: 5)
+    let name = builder.create(string: "Orc")
+    let inventory: [UInt8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    let inv = builder.createVector(inventory, size: 10)
+    let weapons = builder.createVector(ofOffsets: [weaponOne, weaponTwo])
+    let path = builder.createVector(ofStructs: [
+      Vec(x: 4.0, y: 5.0, z: 6.0),
+      Vec(x: 1.0, y: 2.0, z: 3.0),
+    ])
+    let orc = FinalMonster.createMonster(
+      builder: &builder,
+      position: Vec(x: 1, y: 2, z: 3),
+      hp: 300,
+      name: name,
+      inventory: inv,
+      color: .red,
+      weapons: weapons,
+      equipment: .Weapon,
+      equippedOffset: weaponTwo,
+      path: path)
+    builder.finish(offset: orc)
+    // swiftformat:disable all
+    XCTAssertEqual(builder.sizedByteArray, [32, 0, 0, 0, 0, 0, 26, 0, 48, 0, 36, 0, 0, 0, 34, 0, 28, 0, 0, 0, 24, 0, 23, 0, 16, 0, 15, 0, 8, 0, 4, 0, 26, 0, 0, 0, 44, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 76, 0, 0, 0, 0, 0, 44, 1, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 0, 0, 0, 0, 128, 64, 0, 0, 160, 64, 0, 0, 192, 64, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 2, 0, 0, 0, 52, 0, 0, 0, 28, 0, 0, 0, 10, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 3, 0, 0, 0, 79, 114, 99, 0, 244, 255, 255, 255, 0, 0, 5, 0, 24, 0, 0, 0, 8, 0, 12, 0, 8, 0, 6, 0, 8, 0, 0, 0, 0, 0, 3, 0, 12, 0, 0, 0, 3, 0, 0, 0, 65, 120, 101, 0, 5, 0, 0, 0, 83, 119, 111, 114, 100, 0, 0, 0])
+    // swiftformat:enable all
+  }
+
+  func testEnumVector() {
+    let vectorOfEnums: [ColorsNameSpace.RGB] = [.blue, .green]
+
+    var builder = FlatBufferBuilder(initialSize: 1)
+    let off = builder.createVector(vectorOfEnums)
+    let start = ColorsNameSpace.Monster.startMonster(&builder)
+    ColorsNameSpace.Monster.add(colors: off, &builder)
+    let end = ColorsNameSpace.Monster.endMonster(&builder, start: start)
+    builder.finish(offset: end)
+    // swiftformat:disable all
+    XCTAssertEqual(builder.sizedByteArray, [12, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 4, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0])
+    // swiftformat:enable all
+    let monster = ColorsNameSpace.Monster
+      .getRootAsMonster(bb: builder.sizedBuffer)
+    XCTAssertEqual(monster.colorsCount, 2)
+    XCTAssertEqual(monster.colors(at: 0), .blue)
+    XCTAssertEqual(monster.colors(at: 1), .green)
+  }
+
+  func testUnionVector() {
+    var fb = FlatBufferBuilder()
+
+    let swordDmg: Int32 = 8
+    let attackStart = Attacker.startAttacker(&fb)
+    Attacker.add(swordAttackDamage: swordDmg, &fb)
+    let attack = Attacker.endAttacker(&fb, start: attackStart)
+
+    let characterType: [Character] = [.belle, .mulan, .bookfan]
+
+    let characters = [
+      fb.create(struct: BookReader(booksRead: 7)),
+      attack,
+      fb.create(struct: BookReader(booksRead: 2)),
+    ]
+    let types = fb.createVector(characterType)
+    let characterVector = fb.createVector(ofOffsets: characters)
+    let end = Movie.createMovie(
+      &fb,
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
+    Movie.finish(&fb, end: end)
+
+    var buffer = fb.sizedBuffer
+    var movie: Movie = getRoot(byteBuffer: &buffer)
+    XCTAssertEqual(movie.charactersTypeCount, Int32(characterType.count))
+    XCTAssertEqual(movie.charactersCount, Int32(characters.count))
+
+    for i in 0..<movie.charactersTypeCount {
+      XCTAssertEqual(movie.charactersType(at: i), characterType[Int(i)])
+    }
+
+    XCTAssertEqual(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      7)
+    XCTAssertEqual(
+      movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage,
+      swordDmg)
+    XCTAssertEqual(
+      movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead,
+      2)
+
+    var objc: MovieT? = movie.unpack()
+    XCTAssertEqual(
+      movie.charactersTypeCount,
+      Int32(objc?.characters.count ?? 0))
+    XCTAssertEqual(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      (objc?.characters[0]?.value as? BookReader)?.booksRead)
+    fb.clear()
+    let newMovie = Movie.pack(&fb, obj: &objc)
+    fb.finish(offset: newMovie)
+
+    var _buffer = fb.sizedBuffer
+    let packedMovie: Movie = getRoot(byteBuffer: &_buffer)
+
+    XCTAssertEqual(
+      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead)
+    XCTAssertEqual(
+      packedMovie.characters(at: 1, type: Attacker.self)?.swordAttackDamage,
+      movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage)
+    XCTAssertEqual(
+      packedMovie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead,
+      movie.characters(at: 2, type: BookReader_Mutable.self)?.booksRead)
+  }
+
+  func testStringUnion() {
+    let string = "Awesome \\\\t\t\nstring!"
+    var fb = FlatBufferBuilder()
+    let stringOffset = fb.create(string: string)
+    let characterType: [Character] = [.bookfan, .other]
+
+    let characters = [
+      fb.create(struct: BookReader(booksRead: 7)),
+      stringOffset,
+    ]
+    let types = fb.createVector(characterType)
+    let characterVector = fb.createVector(ofOffsets: characters)
+
+    let end = Movie.createMovie(
+      &fb,
+      mainCharacterType: .other,
+      mainCharacterOffset: Offset(offset: stringOffset.o),
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
+    Movie.finish(&fb, end: end)
+
+    var buffer = fb.sizedBuffer
+    var movie: Movie = getRoot(byteBuffer: &buffer)
+    XCTAssertEqual(movie.mainCharacter(type: String.self), string)
+    XCTAssertEqual(
+      movie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      7)
+    XCTAssertEqual(movie.characters(at: 1, type: String.self), string)
+
+    var objc: MovieT? = movie.unpack()
+    XCTAssertEqual(objc?.mainCharacter?.value as? String, string)
+    XCTAssertEqual((objc?.characters[0]?.value as? BookReader)?.booksRead, 7)
+    XCTAssertEqual(objc?.characters[1]?.value as? String, string)
+    fb.clear()
+    let newMovie = Movie.pack(&fb, obj: &objc)
+    fb.finish(offset: newMovie)
+
+    var _buffer = fb.sizedBuffer
+    let packedMovie: Movie = getRoot(byteBuffer: &_buffer)
+    XCTAssertEqual(packedMovie.mainCharacter(type: String.self), string)
+    XCTAssertEqual(
+      packedMovie.characters(at: 0, type: BookReader_Mutable.self)?.booksRead,
+      7)
+    XCTAssertEqual(packedMovie.characters(at: 1, type: String.self), string)
+  }
+
+  func testEncoding() {
+    let string = "Awesome \\\\t\t\nstring!"
+    var fb = FlatBufferBuilder()
+
+    let stringOffset = fb.create(string: string)
+
+    let swordDmg: Int32 = 8
+    let attackStart = Attacker.startAttacker(&fb)
+    Attacker.add(swordAttackDamage: swordDmg, &fb)
+    let attack = Attacker.endAttacker(&fb, start: attackStart)
+
+    let characterType: [Character] = [.belle, .mulan, .bookfan, .other]
+
+    let characters = [
+      fb.create(struct: BookReader(booksRead: 7)),
+      attack,
+      fb.create(struct: BookReader(booksRead: 2)),
+      stringOffset,
+    ]
+    let types = fb.createVector(characterType)
+    let characterVector = fb.createVector(ofOffsets: characters)
+    let end = Movie.createMovie(
+      &fb,
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
+    Movie.finish(&fb, end: end)
+
+    var sizedBuffer = fb.sizedBuffer
+    do {
+      let reader: Movie = try getCheckedRoot(byteBuffer: &sizedBuffer)
+      let encoder = JSONEncoder()
+      encoder.keyEncodingStrategy = .convertToSnakeCase
+      _ = try encoder.encode(reader)
+    } catch {
+      XCTFail(error.localizedDescription)
+    }
+  }
+
+  var jsonData: String {
+    "{\"characters_type\":[\"Belle\",\"MuLan\",\"BookFan\",\"Other\"],\"characters\":[{\"books_read\":7},{\"sword_attack_damage\":8},{\"books_read\":2},\"Awesome \\\\\\\\t\\t\\nstring!\"]}"
+  }
+}
+
+public enum ColorsNameSpace {
+
+  enum RGB: Int32, Enum {
+    typealias T = Int32
+    static var byteSize: Int { MemoryLayout<Int32>.size }
+    var value: Int32 { rawValue }
+    case red = 0, green = 1, blue = 2
+  }
+
+  struct Monster: FlatBufferObject {
+    var __buffer: ByteBuffer! { _accessor.bb }
+
+    private var _accessor: Table
+    static func getRootAsMonster(bb: ByteBuffer) -> Monster { Monster(Table(
+      bb: bb,
+      position: Int32(bb.read(def: UOffset.self, position: bb.reader)) +
+        Int32(bb.reader))) }
+
+    init(_ t: Table) { _accessor = t }
+    init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public var colorsCount: Int32 {
+      let o = _accessor.offset(4); return o == 0 ? 0 : _accessor
+        .vector(count: o) }
+    public func colors(at index: Int32) -> ColorsNameSpace
+      .RGB?
+    { let o = _accessor.offset(4); return o == 0 ? ColorsNameSpace
+      .RGB(rawValue: 0)! : ColorsNameSpace.RGB(rawValue: _accessor.directRead(
+        of: Int32.self,
+        offset: _accessor.vector(at: o) + index * 4)) }
+    static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb
+      .startTable(with: 1) }
+    static func add(colors: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(
+      offset: colors,
+      at: 4)  }
+    static func endMonster(
+      _ fbb: inout FlatBufferBuilder,
+      start: UOffset)
+      -> Offset
+    { let end = Offset(offset: fbb.endTable(at: start)); return end
+    }
+  }
+}
+
+
+enum Equipment: Byte { case none, Weapon }
+
+enum Color3: Int8 { case red = 0, green, blue }
+
+struct FinalMonster {
+
+  @inlinable
+  static func createMonster(
+    builder: inout FlatBufferBuilder,
+    position: Vec,
+    hp: Int16,
+    name: Offset,
+    inventory: Offset,
+    color: Color3,
+    weapons: Offset,
+    equipment: Equipment = .none,
+    equippedOffset: Offset,
+    path: Offset) -> Offset
+  {
+    let start = builder.startTable(with: 11)
+    builder.create(struct: position, position: 4)
+    builder.add(element: hp, def: 100, at: 8)
+    builder.add(offset: name, at: 10)
+    builder.add(offset: inventory, at: 14)
+    builder.add(element: color.rawValue, def: Color3.green.rawValue, at: 16)
+    builder.add(offset: weapons, at: 18)
+    builder.add(
+      element: equipment.rawValue,
+      def: Equipment.none.rawValue,
+      at: 20)
+    builder.add(offset: equippedOffset, at: 22)
+    builder.add(offset: path, at: 24)
+    return Offset(offset: builder.endTable(at: start))
+  }
+}
+
+struct LocalMonster {
+
+  private var __t: Table
+
+  init(_ fb: ByteBuffer, o: Int32) { __t = Table(bb: fb, position: o) }
+  init(_ t: Table) { __t = t }
+
+  func weapon(at index: Int32) -> Weapon? { let o = __t
+    .offset(4); return o == 0 ? nil : Weapon.assign(
+      __t.indirect(__t.vector(at: o) + (index * 4)),
+      __t.bb) }
+
+  func equiped<T: FlatBufferObject>() -> T? {
+    let o = __t.offset(8); return o == 0 ? nil : __t.union(o)
+  }
+
+  static func getRootAsMonster(bb: ByteBuffer) -> LocalMonster {
+    LocalMonster(Table(
+      bb: bb,
+      position: Int32(bb.read(def: UOffset.self, position: 0))))
+  }
+
+  @inlinable
+  static func createMonster(
+    builder: inout FlatBufferBuilder,
+    offset: Offset,
+    equipment: Equipment = .none,
+    equippedOffset: UOffset) -> Offset
+  {
+    let start = builder.startTable(with: 3)
+    builder.add(element: equippedOffset, def: 0, at: 8)
+    builder.add(offset: offset, at: 4)
+    builder.add(
+      element: equipment.rawValue,
+      def: Equipment.none.rawValue,
+      at: 6)
+    return Offset(offset: builder.endTable(at: start))
+  }
+}
+
+struct Weapon: FlatBufferObject {
+
+  var __buffer: ByteBuffer! { __t.bb }
+
+  static let offsets: (name: VOffset, dmg: VOffset) = (4, 6)
+  private var __t: Table
+
+  init(_ t: Table) { __t = t }
+  init(_ fb: ByteBuffer, o: Int32) { __t = Table(bb: fb, position: o)}
+
+  var dmg: Int16 { let o = __t.offset(6); return o == 0 ? 0 : __t.readBuffer(
+    of: Int16.self,
+    at: o) }
+  var nameVector: [UInt8]? { __t.getVector(at: 4) }
+  var name: String? {
+    let o = __t.offset(4); return o == 0 ? nil : __t.string(at: o) }
+
+  static func assign(_ i: Int32, _ bb: ByteBuffer) -> Weapon { Weapon(Table(
+    bb: bb,
+    position: i)) }
+
+  @inlinable
+  static func createWeapon(
+    builder: inout FlatBufferBuilder,
+    offset: Offset,
+    dmg: Int16) -> Offset
+  {
+    let _start = builder.startTable(with: 2)
+    Weapon.add(builder: &builder, name: offset)
+    Weapon.add(builder: &builder, dmg: dmg)
+    return Weapon.end(builder: &builder, startOffset: _start)
+  }
+
+  @inlinable
+  static func end(
+    builder: inout FlatBufferBuilder,
+    startOffset: UOffset) -> Offset
+  {
+    Offset(offset: builder.endTable(at: startOffset))
+  }
+
+  @inlinable
+  static func add(builder: inout FlatBufferBuilder, name: Offset) {
+    builder.add(offset: name, at: Weapon.offsets.name)
+  }
+
+  @inlinable
+  static func add(builder: inout FlatBufferBuilder, dmg: Int16) {
+    builder.add(element: dmg, def: 0, at: Weapon.offsets.dmg)
+  }
+}

tests/swift/Tests/Flatbuffers/FlatBuffersVectorsTests.swift

@@ -0,0 +1,214 @@
+/*
+ * 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 XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersVectors: XCTestCase {
+
+  func testCreatingTwoCountries() {
+    let norway = "Norway"
+    let denmark = "Denmark"
+    var b = FlatBufferBuilder(initialSize: 20)
+    let noStr = b.create(string: norway)
+    let deStr = b.create(string: denmark)
+    let n = Country.createCountry(
+      builder: &b,
+      offset: noStr,
+      log: 888,
+      lan: 700)
+    let d = Country.createCountry(
+      builder: &b,
+      offset: deStr,
+      log: 200,
+      lan: 100)
+    let vector = [n, d]
+    let vectorOffset = b.createVector(ofOffsets: vector)
+    b.finish(offset: vectorOffset)
+    // swiftformat:disable all
+    XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 2, 0, 0, 0, 48, 0, 0, 0, 16, 0, 0, 0, 0, 0, 10, 0, 18, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 40, 0, 0, 0, 100, 0, 0, 0, 200, 0, 0, 0, 0, 0, 10, 0, 16, 0, 4, 0, 8, 0, 12, 0, 10, 0, 0, 0, 24, 0, 0, 0, 188, 2, 0, 0, 120, 3, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0])
+    // swiftformat:enable all
+  }
+
+  func testCreateIntArray() {
+    let numbers: [Int32] = [1, 2, 3, 4, 5]
+    var b = FlatBufferBuilder(initialSize: 20)
+    let o = b.createVector(numbers, size: numbers.count)
+    b.finish(offset: o)
+    // swiftformat:disable all
+    XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 5, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0])
+    // swiftformat:enable all
+  }
+
+  func testCreateStructArray() {
+    struct Vec: NativeStruct {
+      let x, y, z: Float32
+    }
+    let vector: [Vec] = [
+      Vec(x: 1, y: 2, z: 3),
+      Vec(x: 4, y: 5, z: 6),
+      Vec(x: 7, y: 8, z: 9),
+    ]
+    var b = FlatBufferBuilder(initialSize: 100)
+    let o = b.createVector(ofStructs: vector)
+    b.finish(offset: o)
+    // swiftformat:disable all
+    XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 3, 0, 0, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 128, 64, 0, 0, 160, 64, 0, 0, 192, 64, 0, 0, 224, 64, 0, 0, 0, 65, 0, 0, 16, 65])
+    // swiftformat:enable all
+  }
+
+  func testCreateEmptyIntArray() {
+    let numbers: [Int32] = []
+    var b = FlatBufferBuilder(initialSize: 20)
+    let o = b.createVector(numbers, size: numbers.count)
+    b.finish(offset: o)
+    XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 0, 0, 0, 0])
+  }
+
+  func testCreateVectorOfStrings() {
+    let strs = ["Denmark", "Norway"]
+    var b = FlatBufferBuilder(initialSize: 20)
+    let o = b.createVector(ofStrings: strs)
+    b.finish(offset: o)
+    // swiftformat:disable all
+    XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 2, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0])
+    // swiftformat:enable all
+  }
+  func testCreateSharedStringVector() {
+    let norway = "Norway"
+    let denmark = "Denmark"
+    var b = FlatBufferBuilder(initialSize: 20)
+    let noStr = b.createShared(string: norway)
+    let deStr = b.createShared(string: denmark)
+    let _noStr = b.createShared(string: norway)
+    let _deStr = b.createShared(string: denmark)
+    let v = [noStr, deStr, _noStr, _deStr]
+    let end = b.createVector(ofOffsets: v)
+    b.finish(offset: end)
+    // swiftformat:disable all
+    XCTAssertEqual(b.sizedByteArray, [4, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 12, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 7, 0, 0, 0, 68, 101, 110, 109, 97, 114, 107, 0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0])
+    // swiftformat:enable all
+  }
+
+  func testReadInt32Array() {
+    let data: [Int32] = [1, 2, 3, 4, 5]
+    var b = FlatBufferBuilder(initialSize: 20)
+    let v = Numbers.createNumbersVector(b: &b, array: data)
+    let end = Numbers.createNumbers(b: &b, o: v)
+    b.finish(offset: end)
+    let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
+    XCTAssertEqual(number.vArrayInt32, [1, 2, 3, 4, 5])
+  }
+
+  func testReadDoubleArray() {
+    let data: [Double] = [1, 2, 3, 4, 5]
+    var b = FlatBufferBuilder(initialSize: 20)
+    let v = Numbers.createNumbersVector(b: &b, array: data)
+    let end = Numbers.createNumbers(b: &b, o: v)
+    b.finish(offset: end)
+    let number = Numbers.getRootAsNumbers(ByteBuffer(bytes: b.sizedByteArray))
+    XCTAssertEqual(number.vArrayDouble, [1, 2, 3, 4, 5])
+  }
+
+  func testHasForArray() {
+    var builder = FlatBufferBuilder(initialSize: 20)
+    let emptyVector = [UInt8]()
+    let emptyOffset = builder.createVector(emptyVector)
+    let nonEmptyVector = [1, 2, 3]
+    let nonEmptyVectorOffest = builder.createVector(nonEmptyVector)
+    let start = Swift_Tests_Vectors.startVectors(&builder)
+    Swift_Tests_Vectors.addVectorOf(empty: emptyOffset, &builder)
+    Swift_Tests_Vectors.addVectorOf(array: nonEmptyVectorOffest, &builder)
+    let finish = Swift_Tests_Vectors.endVectors(&builder, start: start)
+    builder.finish(offset: finish)
+
+    var byteBuffer = ByteBuffer(bytes: builder.sizedByteArray)
+    let msg: Swift_Tests_Vectors = getRoot(byteBuffer: &byteBuffer)
+    XCTAssertEqual(msg.hasNone, false)
+    XCTAssertEqual(msg.hasEmpty, true)
+    XCTAssertEqual(msg.emptyCount, 0)
+    XCTAssertEqual(msg.hasArray, true)
+    XCTAssertEqual(msg.arrayCount, 3)
+    XCTAssertEqual(msg.array, [1, 2, 3])
+
+
+    let array = msg.withUnsafePointerToArray { ptr in
+      let ptr: UnsafeBufferPointer<UInt64> = UnsafeBufferPointer(
+        start: ptr.baseAddress?.bindMemory(
+          to: UInt64.self,
+          capacity: Int(msg.arrayCount)),
+        count: Int(msg.arrayCount))
+      return Array(ptr)
+    }
+
+    XCTAssertEqual(array, [1, 2, 3])
+  }
+}
+
+struct Numbers {
+
+  private var __t: Table
+
+  private init(_ t: Table) {
+    __t = t
+  }
+
+  @inlinable
+  static func getRootAsNumbers(_ bb: ByteBuffer) -> Numbers {
+    Numbers(Table(
+      bb: bb,
+      position: Int32(bb.read(def: UOffset.self, position: 0))))
+  }
+
+  var vArrayInt: [Int]? { __t.getVector(at: 4) }
+  var vArrayInt32: [Int32]? { __t.getVector(at: 4) }
+  var vArrayDouble: [Double]? { __t.getVector(at: 4) }
+  var vArrayFloat: [Float32]? { __t.getVector(at: 4) }
+
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Int]) -> Offset
+  {
+    b.createVector(array, size: array.count)
+  }
+
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Int32]) -> Offset
+  {
+    b.createVector(array, size: array.count)
+  }
+
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Double]) -> Offset
+  {
+    b.createVector(array, size: array.count)
+  }
+
+  static func createNumbersVector(
+    b: inout FlatBufferBuilder,
+    array: [Float32]) -> Offset
+  {
+    b.createVector(array, size: array.count)
+  }
+
+  static func createNumbers(b: inout FlatBufferBuilder, o: Offset) -> Offset {
+    let start = b.startTable(with: 1)
+    b.add(offset: o, at: 4)
+    return Offset(offset: b.endTable(at: start))
+  }
+}

tests/swift/Tests/Flatbuffers/FlatbuffersDoubleTests.swift

@@ -0,0 +1,124 @@
+/*
+ * 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 XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersDoubleTests: XCTestCase {
+
+  let country = "Norway"
+
+  func testCreateFinish() {
+    var b = FlatBufferBuilder(initialSize: 16)
+    let countryOff = CountryDouble.createCountry(
+      builder: &b,
+      name: country,
+      log: 200,
+      lan: 100)
+    b.finish(offset: countryOff)
+    // swiftformat:disable all
+    let v: [UInt8] = [
+      16, 0, 0, 0, 0, 0, 10, 0, 28, 0, 4, 0, 8, 0, 16, 0, 10,
+      0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 89, 64, 0, 0, 0,
+      0, 0, 0, 105, 64, 0, 0, 0, 0, 6, 0, 0, 0, 78, 111, 114, 119,
+      97, 121, 0, 0
+    ]
+    // swiftformat:enable all
+    XCTAssertEqual(b.sizedByteArray, v)
+  }
+
+  func testCreateFinishWithPrefix() {
+    var b = FlatBufferBuilder(initialSize: 16)
+    let countryOff = CountryDouble.createCountry(
+      builder: &b,
+      name: country,
+      log: 200,
+      lan: 100)
+    b.finish(offset: countryOff, addPrefix: true)
+    // swiftformat:disable all
+    let v: [UInt8] = [
+      60, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 28
+      , 0, 4, 0, 8, 0, 16, 0, 10, 0, 0, 0, 24, 0, 0, 0, 0, 0,
+      0, 0, 0, 0, 89, 64, 0, 0, 0, 0, 0, 0, 105, 64, 0, 0, 0,
+      0, 6, 0, 0, 0, 78, 111, 114, 119, 97, 121, 0, 0
+    ]
+    // swiftformat:enable all
+    XCTAssertEqual(b.sizedByteArray, v)
+  }
+}
+
+class CountryDouble {
+
+  static let offsets: (name: VOffset, lan: VOffset, lng: VOffset) = (4, 6, 8)
+
+  private var table: Table
+
+  private init(table t: Table) { table = t }
+
+  static func getRootAsCountry(_ bb: ByteBuffer) -> CountryDouble {
+    let pos = bb.read(def: Int32.self, position: Int(bb.size))
+    return CountryDouble(table: Table(bb: bb, position: Int32(pos)))
+  }
+
+  static func createCountry(
+    builder: inout FlatBufferBuilder,
+    name: String,
+    log: Double,
+    lan: Double) -> Offset
+  {
+    createCountry(
+      builder: &builder,
+      offset: builder.create(string: name),
+      log: log,
+      lan: lan)
+  }
+
+  static func createCountry(
+    builder: inout FlatBufferBuilder,
+    offset: Offset,
+    log: Double,
+    lan: Double) -> Offset
+  {
+    let _start = builder.startTable(with: 3)
+    CountryDouble.add(builder: &builder, lng: log)
+    CountryDouble.add(builder: &builder, lan: lan)
+    CountryDouble.add(builder: &builder, name: offset)
+    return CountryDouble.end(builder: &builder, startOffset: _start)
+  }
+
+  static func end(
+    builder: inout FlatBufferBuilder,
+    startOffset: UOffset) -> Offset
+  {
+    Offset(offset: builder.endTable(at: startOffset))
+  }
+
+  static func add(builder: inout FlatBufferBuilder, name: String) {
+    add(builder: &builder, name: builder.create(string: name))
+  }
+
+  static func add(builder: inout FlatBufferBuilder, name: Offset) {
+    builder.add(offset: name, at: Country.offsets.name)
+  }
+
+  static func add(builder: inout FlatBufferBuilder, lan: Double) {
+    builder.add(element: lan, def: 0, at: Country.offsets.lan)
+  }
+
+  static func add(builder: inout FlatBufferBuilder, lng: Double) {
+    builder.add(element: lng, def: 0, at: Country.offsets.lng)
+  }
+}

tests/swift/Tests/Flatbuffers/FlatbuffersMoreDefaults.swift

@@ -0,0 +1,86 @@
+/*
+ * 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
+import XCTest
+@testable import FlatBuffers
+
+class FlatBuffersMoreDefaults: XCTestCase {
+
+  func testFlatbuffersObject() {
+    var fbb = FlatBufferBuilder()
+    let root = MoreDefaults.createMoreDefaults(&fbb)
+    fbb.finish(offset: root)
+    var byteBuffer = fbb.sizedBuffer
+    let defaults: MoreDefaults = getRoot(byteBuffer: &byteBuffer)
+    XCTAssertEqual(defaults.emptyString, "")
+    XCTAssertEqual(defaults.someString, "some")
+    XCTAssertEqual(defaults.ints, [])
+    XCTAssertEqual(defaults.floats, [])
+    XCTAssertEqual(defaults.bools, [])
+    XCTAssertEqual(defaults.intsCount, 0)
+    XCTAssertEqual(defaults.floatsCount, 0)
+    XCTAssertEqual(defaults.abcsCount, 0)
+    XCTAssertEqual(defaults.boolsCount, 0)
+  }
+
+  func testFlatbuffersObjectAPI() {
+    var fbb = FlatBufferBuilder()
+    let defaults = MoreDefaultsT()
+    XCTAssertEqual(defaults.emptyString, "")
+    XCTAssertEqual(defaults.someString, "some")
+    XCTAssertEqual(defaults.ints, [])
+    XCTAssertEqual(defaults.floats, [])
+    XCTAssertEqual(defaults.abcs, [])
+    XCTAssertEqual(defaults.bools, [])
+
+    var buffer = defaults.serialize(builder: &fbb, type: MoreDefaults.self)
+    let fDefaults: MoreDefaults = getRoot(byteBuffer: &buffer)
+    XCTAssertEqual(fDefaults.emptyString, "")
+    XCTAssertEqual(fDefaults.someString, "some")
+    XCTAssertEqual(fDefaults.ints, [])
+    XCTAssertEqual(fDefaults.floats, [])
+    XCTAssertEqual(fDefaults.intsCount, 0)
+    XCTAssertEqual(fDefaults.floatsCount, 0)
+    XCTAssertEqual(fDefaults.abcsCount, 0)
+    XCTAssertEqual(fDefaults.boolsCount, 0)
+  }
+
+  func testEncoding() {
+    var fbb = FlatBufferBuilder()
+    let root = MoreDefaults.createMoreDefaults(&fbb)
+    fbb.finish(offset: root)
+    var sizedBuffer = fbb.sizedBuffer
+    do {
+      struct Test: Decodable {
+        var emptyString: String
+        var someString: String
+      }
+      let reader: MoreDefaults = try getCheckedRoot(byteBuffer: &sizedBuffer)
+      let encoder = JSONEncoder()
+      encoder.keyEncodingStrategy = .convertToSnakeCase
+      let data = try encoder.encode(reader)
+      let decoder = JSONDecoder()
+      decoder.keyDecodingStrategy = .convertFromSnakeCase
+      let value = try decoder.decode(Test.self, from: data)
+      XCTAssertEqual(value.someString, "some")
+      XCTAssertEqual(value.emptyString, "")
+    } catch {
+      XCTFail(error.localizedDescription)
+    }
+  }
+
+}

tests/swift/Tests/Flatbuffers/FlatbuffersVerifierTests.swift

@@ -0,0 +1,347 @@
+/*
+ * 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 XCTest
+@testable import FlatBuffers
+
+final class FlatbuffersVerifierTests: XCTestCase {
+
+  lazy var validStorage: ByteBuffer.Storage = ByteBuffer.Storage(
+    count: Int(FlatBufferMaxSize) - 1)
+  lazy var errorStorage: ByteBuffer.Storage = ByteBuffer.Storage(
+    count: Int(FlatBufferMaxSize) + 1)
+
+  var buffer: ByteBuffer!
+
+  var validFlatbuffersObject: ByteBuffer!
+  var invalidFlatbuffersObject: ByteBuffer!
+  var invalidFlatbuffersObject2: ByteBuffer!
+  var invalidFlatbuffersObject3: ByteBuffer!
+
+  override func setUp() {
+    // swiftformat:disable all
+    let memory = UnsafeMutableRawPointer.allocate(byteCount: 32, alignment: 1)
+    buffer = ByteBuffer(assumingMemoryBound: memory, capacity: 32)
+    add(buffer: &buffer, v: 4, p: 16)
+    add(buffer: &buffer, v: 4, p: 20)
+
+    validFlatbuffersObject = ByteBuffer(bytes: [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+
+    invalidFlatbuffersObject = ByteBuffer(bytes: [0, 48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+
+    // Array failure within a the inventory array
+    invalidFlatbuffersObject2 = ByteBuffer(bytes: [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 0x00, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0])
+
+    // Array failure within a the strings array
+    invalidFlatbuffersObject3 = ByteBuffer(bytes: [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 0x00, 111, 0, 0, 0])
+    // swiftformat:enable all
+  }
+
+  func testVeriferInitPassing() {
+    let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
+    var buffer = ByteBuffer(assumingMemoryBound: memory, capacity: 8)
+    buffer._storage = validStorage
+    XCTAssertNoThrow(try Verifier(buffer: &buffer))
+  }
+
+  func testVeriferInitFailing() {
+    let memory = UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 1)
+    var buffer = ByteBuffer(assumingMemoryBound: memory, capacity: 8)
+    buffer._storage = errorStorage
+    XCTAssertThrowsError(try Verifier(buffer: &buffer))
+  }
+
+  func testFailingID() {
+    let dutData : [UInt8] = [1,2,3,4,5,6,7]
+    var buff  = ByteBuffer(bytes: dutData)
+    do {
+      let _: Monster = try getCheckedRoot(byteBuffer: &buff, fileId: "ABCD")
+      XCTFail("This should always fail")
+    } catch {
+      XCTAssertEqual(error as? FlatbuffersErrors, .bufferDoesntContainID)
+    }
+  }
+
+  func testVerifierCheckAlignment() {
+    let verifier = try! Verifier(buffer: &buffer)
+    do {
+      try verifier.isAligned(position: 20, type: Int.self)
+    } catch {
+      XCTAssertEqual(
+        error as? FlatbuffersErrors,
+        .missAlignedPointer(position: 20, type: "Int"))
+    }
+    XCTAssertNoThrow(try verifier.isAligned(position: 16, type: Int.self))
+
+    let newVerifer = try! Verifier(buffer: &buffer, checkAlignment: false)
+    XCTAssertNoThrow(try newVerifer.isAligned(position: 16, type: Int.self))
+  }
+
+  func testRangeInBuffer() {
+    var verifier = try! Verifier(buffer: &buffer)
+    let size = MemoryLayout<Int64>.size
+    XCTAssertNoThrow(try verifier.rangeInBuffer(position: 24, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 26, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 30, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 32, size: size))
+    XCTAssertThrowsError(try verifier.rangeInBuffer(position: 34, size: size))
+
+    verifier = try! Verifier(
+      buffer: &buffer,
+      options: .init(maxDepth: 0, maxTableCount: 0, maxApparentSize: 4))
+    do {
+      try verifier.rangeInBuffer(position: 24, size: size)
+    } catch {
+      XCTAssertEqual(
+        error as! FlatbuffersErrors,
+        .apparentSizeTooLarge)
+    }
+  }
+
+  func testPositionInBuffer() {
+    let verifier = try! Verifier(buffer: &buffer)
+    XCTAssertNoThrow(try verifier.inBuffer(position: 0, of: Int64.self))
+    XCTAssertNoThrow(try verifier.inBuffer(position: 24, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: -9, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 25, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int32.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 26, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 30, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 32, of: Int64.self))
+    XCTAssertThrowsError(try verifier.inBuffer(position: 34, of: Int64.self))
+  }
+
+  func testVisitTable() {
+    var verifier = try! Verifier(buffer: &validFlatbuffersObject)
+    XCTAssertNoThrow(try verifier.visitTable(at: 48))
+    verifier.reset()
+  }
+
+  func testTableVerifier() {
+    var verifier = try! Verifier(buffer: &validFlatbuffersObject)
+
+    var tableVerifer = try! verifier.visitTable(at: 48)
+    XCTAssertEqual(verifier.depth, 1)
+    XCTAssertEqual(verifier.tableCount, 1)
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 4,
+      fieldName: "Vec",
+      required: false,
+      type: Vec3.self))
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 8,
+      fieldName: "hp",
+      required: false,
+      type: Int16.self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 10,
+      fieldName: "name",
+      required: true,
+      type: ForwardOffset<String>.self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 14,
+      fieldName: "inventory",
+      required: false,
+      type: ForwardOffset<Vector<UInt8, UInt8>>.self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 22,
+      fieldName: "test4",
+      required: false,
+      type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>
+        .self))
+
+    XCTAssertNoThrow(try tableVerifer.visit(
+      field: 24,
+      fieldName: "Vector of strings",
+      required: false,
+      type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self))
+
+    do {
+      try tableVerifer.visit(
+        field: 13,
+        fieldName: "notvalid",
+        required: false,
+        type: Int16.self)
+    } catch {
+      XCTAssertEqual(
+        error as! FlatbuffersErrors,
+        .missAlignedPointer(position: 25, type: "UInt16"))
+    }
+
+    do {
+      try tableVerifer.visit(
+        unionKey: 18,
+        unionField: 20,
+        unionKeyName: "testType",
+        fieldName: "test",
+        required: false,
+        completion: { (verifier, key: MyGame_Example_Any_, pos) in
+          switch key {
+          case .none_:
+            break
+          case .monster:
+            try ForwardOffset<MyGame_Example_Monster>.verify(
+              &verifier,
+              at: pos,
+              of: MyGame_Example_Monster.self)
+
+          case .testsimpletablewithenum:
+            break
+          case .mygameExample2Monster:
+            break
+          }
+        })
+    } catch {
+      XCTAssertEqual(
+        error as! FlatbuffersErrors,
+        .missAlignedPointer(position: 25, type: "UInt16"))
+    }
+    tableVerifer.finish()
+    XCTAssertEqual(verifier.depth, 0)
+  }
+
+  func testVerifyUnionVectors() {
+    // swiftformat:disable all
+    var byteBuffer = ByteBuffer(bytes: [20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0, 20, 0, 0, 0, 3, 0, 0, 0, 24, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 3, 0, 0, 0, 3, 1, 4, 0, 2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0])
+    // swiftformat:enable all
+    XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &byteBuffer) as Movie)
+  }
+
+  func testErrorWrongFileId() {
+    // swiftformat:disable all
+    var byteBuffer = ByteBuffer(bytes: [20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0, 20, 0, 0, 0, 3, 0, 0, 0, 24, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 3, 0, 0, 0, 3, 1, 4, 0, 2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0])
+    // swiftformat:enable all
+    XCTAssertThrowsError(try getCheckedRoot(
+      byteBuffer: &byteBuffer,
+      fileId: "FLEX") as Movie)
+  }
+
+  func testVerifyPrefixedBuffer() {
+    // swiftformat:disable all
+    var byteBuffer = ByteBuffer(bytes: [0, 0, 0, 1, 20, 0, 0, 0, 77, 79, 86, 73, 12, 0, 12, 0, 0, 0, 0, 0, 8, 0, 4, 0, 12, 0, 0, 0, 8, 0, 0, 0, 20, 0, 0, 0, 3, 0, 0, 0, 24, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 3, 0, 0, 0, 3, 1, 4, 0, 2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 6, 0, 8, 0, 4, 0, 6, 0, 0, 0, 8, 0, 0, 0])
+    // swiftformat:enable all
+    XCTAssertThrowsError(
+      try getCheckedPrefixedSizeRoot(byteBuffer: &byteBuffer) as Movie)
+  }
+
+  func testFullVerifier() {
+    XCTAssertNoThrow(
+      try getCheckedRoot(
+        byteBuffer: &validFlatbuffersObject) as MyGame_Example_Monster)
+  }
+
+  func testFullVerifierWithFileId() {
+    XCTAssertNoThrow(
+      try getCheckedRoot(
+        byteBuffer: &validFlatbuffersObject,
+        fileId: MyGame_Example_Monster.id) as MyGame_Example_Monster)
+  }
+
+  func testInvalidBuffer() {
+    XCTAssertThrowsError(
+      try getCheckedRoot(
+        byteBuffer: &invalidFlatbuffersObject) as MyGame_Example_Monster)
+  }
+
+  func testInvalidBuffer2() {
+    XCTAssertThrowsError(
+      try getCheckedRoot(
+        byteBuffer: &invalidFlatbuffersObject2) as MyGame_Example_Monster)
+  }
+
+  func testInvalidBuffer3() {
+    XCTAssertThrowsError(
+      try getCheckedRoot(
+        byteBuffer: &invalidFlatbuffersObject3) as MyGame_Example_Monster)
+  }
+
+  func testValidUnionBuffer() {
+    let string = "Awesome \\\\t\t\nstring!"
+    var fb = FlatBufferBuilder()
+    let stringOffset = fb.create(string: string)
+    let characterType: [Character] = [.bookfan, .other]
+
+    let characters = [
+      fb.create(struct: BookReader(booksRead: 7)),
+      stringOffset,
+    ]
+    let types = fb.createVector(characterType)
+    let characterVector = fb.createVector(ofOffsets: characters)
+
+    let end = Movie.createMovie(
+      &fb,
+      mainCharacterType: .other,
+      mainCharacterOffset: Offset(offset: stringOffset.o),
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
+    Movie.finish(&fb, end: end)
+    var buf = fb.sizedBuffer
+    XCTAssertNoThrow(try getCheckedRoot(byteBuffer: &buf) as Movie)
+  }
+
+  func testNestedTables() throws {
+    var builder = FlatBufferBuilder()
+    let name = builder.create(string: "Monster")
+
+    let enemy = MyGame_Example_Monster.createMonster(
+      &builder,
+      nameOffset: name)
+    let currentName = builder.create(string: "Main name")
+    let monster = MyGame_Example_Monster.createMonster(
+      &builder,
+      nameOffset: currentName,
+      enemyOffset: enemy)
+    builder.finish(offset: monster)
+
+    var sizedBuffer = builder.sizedBuffer
+    var verifier = try! Verifier(buffer: &sizedBuffer)
+    var tableVerifer = try! verifier.visitTable(
+      at: try getOffset(at: 0, within: verifier))
+    XCTAssertEqual(verifier.depth, 1)
+    XCTAssertEqual(verifier.tableCount, 1)
+
+    let position = try tableVerifer.dereference(28)!
+
+    var nestedTable = try verifier.visitTable(
+      at: try getOffset(at: position, within: verifier))
+
+    XCTAssertEqual(verifier.depth, 2)
+    XCTAssertEqual(verifier.tableCount, 2)
+    nestedTable.finish()
+    XCTAssertEqual(verifier.depth, 1)
+    XCTAssertEqual(verifier.tableCount, 2)
+    tableVerifer.finish()
+    XCTAssertEqual(verifier.depth, 0)
+    XCTAssertEqual(verifier.tableCount, 2)
+  }
+
+  func add(buffer: inout ByteBuffer, v: Int32, p: Int) {
+    buffer.write(value: v, index: p)
+  }
+
+  private func getOffset(
+    at value: Int,
+    within verifier: Verifier) throws -> Int
+  {
+    let offset: UOffset = try verifier.getValue(at: value)
+    return Int(clamping: (Int(offset) &+ 0).magnitude)
+  }
+}

tests/swift/Tests/Flatbuffers/MutatingBool_generated.swift

@@ -0,0 +1,151 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public struct Property: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+
+  private var _property: Bool
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _property = _accessor.readBuffer(of: Bool.self, at: 0)
+  }
+
+  public init(property: Bool) {
+    _property = property
+  }
+
+  public init() {
+    _property = false
+  }
+
+  public init(_ _t: inout Property_Mutable) {
+    _property = _t.property
+  }
+
+  public var property: Bool { _property }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: Property.self)
+  }
+}
+
+extension Property: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case property = "property"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if property != false {
+      try container.encodeIfPresent(property, forKey: .property)
+    }
+  }
+}
+
+public struct Property_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Struct
+
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+  public var property: Bool { return _accessor.readBuffer(of: Bool.self, at: 0) }
+  @discardableResult public func mutate(property: Bool) -> Bool { return _accessor.mutate(property, index: 0) }
+  
+
+  public mutating func unpack() -> Property {
+    return Property(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Property?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Property) -> Offset {
+    return builder.create(struct: obj)
+  }
+}
+
+public struct TestMutatingBool: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case b = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var b: Property? { let o = _accessor.offset(VTOFFSET.b.v); return o == 0 ? nil : _accessor.readBuffer(of: Property.self, at: o) }
+  public var mutableB: Property_Mutable? { let o = _accessor.offset(VTOFFSET.b.v); return o == 0 ? nil : Property_Mutable(_accessor.bb, o: o + _accessor.position) }
+  public static func startTestMutatingBool(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(b: Property?, _ fbb: inout FlatBufferBuilder) { guard let b = b else { return }; fbb.create(struct: b, position: VTOFFSET.b.p) }
+  public static func endTestMutatingBool(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createTestMutatingBool(
+    _ fbb: inout FlatBufferBuilder,
+    b: Property? = nil
+  ) -> Offset {
+    let __start = TestMutatingBool.startTestMutatingBool(&fbb)
+    TestMutatingBool.add(b: b, &fbb)
+    return TestMutatingBool.endTestMutatingBool(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> TestMutatingBoolT {
+    return TestMutatingBoolT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout TestMutatingBoolT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout TestMutatingBoolT) -> Offset {
+    let __root = TestMutatingBool.startTestMutatingBool(&builder)
+    TestMutatingBool.add(b: obj.b, &builder)
+    return TestMutatingBool.endTestMutatingBool(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.b.p, fieldName: "b", required: false, type: Property.self)
+    _v.finish()
+  }
+}
+
+extension TestMutatingBool: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case b = "b"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    try container.encodeIfPresent(b, forKey: .b)
+  }
+}
+
+public class TestMutatingBoolT: NativeObject {
+
+  public var b: Property?
+
+  public init(_ _t: inout TestMutatingBool) {
+    b = _t.b
+  }
+
+  public init() {
+    b = Property()
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: TestMutatingBool.self) }
+
+}

tests/swift/Tests/Flatbuffers/monster_test.grpc.swift

@@ -0,0 +1,210 @@
+// Generated GRPC code for FlatBuffers swift!
+/// The following code is generated by the Flatbuffers library which might not be in sync with grpc-swift
+/// in case of an issue please open github issue, though it would be maintained
+
+// swiftlint:disable all
+// swiftformat:disable all
+
+#if !os(Windows)
+import Foundation
+import GRPC
+import NIO
+import NIOHTTP1
+import FlatBuffers
+
+public protocol GRPCFlatBufPayload: GRPCPayload, FlatBufferGRPCMessage {}
+public extension GRPCFlatBufPayload {
+  init(serializedByteBuffer: inout NIO.ByteBuffer) throws {
+    self.init(byteBuffer: FlatBuffers.ByteBuffer(contiguousBytes: serializedByteBuffer.readableBytesView, count: serializedByteBuffer.readableBytes))
+  }
+  func serialize(into buffer: inout NIO.ByteBuffer) throws {
+    withUnsafeReadableBytes { buffer.writeBytes($0) }
+  }
+}
+extension Message: GRPCFlatBufPayload {}
+
+/// Usage: instantiate MyGame_Example_MonsterStorageServiceClient, then call methods of this protocol to make API calls.
+public protocol MyGame_Example_MonsterStorageClientProtocol: GRPCClient {
+
+  var serviceName: String { get }
+
+  var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? { get }
+
+  func Store(
+    _ request: Message<MyGame_Example_Monster>
+    , callOptions: CallOptions?
+  ) -> UnaryCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
+
+  func Retrieve(
+    _ request: Message<MyGame_Example_Stat>
+    , callOptions: CallOptions?,
+    handler: @escaping (Message<MyGame_Example_Monster>) -> Void
+  ) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>
+
+  func GetMaxHitPoint(
+    callOptions: CallOptions?
+  ) -> ClientStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
+
+  func GetMinMaxHitPoints(
+    callOptions: CallOptions?,
+    handler: @escaping (Message<MyGame_Example_Stat> ) -> Void
+  ) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>
+
+}
+
+extension MyGame_Example_MonsterStorageClientProtocol {
+
+  public var serviceName: String { "MyGame.Example.MonsterStorage" }
+
+  public func Store(
+    _ request: Message<MyGame_Example_Monster>
+    , callOptions: CallOptions? = nil
+  ) -> UnaryCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
+    return self.makeUnaryCall(
+      path: "/MyGame.Example.MonsterStorage/Store",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeStoreInterceptors() ?? []
+    )
+  }
+
+  public func Retrieve(
+    _ request: Message<MyGame_Example_Stat>
+    , callOptions: CallOptions? = nil,
+    handler: @escaping (Message<MyGame_Example_Monster>) -> Void
+  ) -> ServerStreamingCall<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>> {
+    return self.makeServerStreamingCall(
+      path: "/MyGame.Example.MonsterStorage/Retrieve",
+      request: request,
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
+      handler: handler
+    )
+  }
+
+  public func GetMaxHitPoint(
+    callOptions: CallOptions? = nil
+  ) -> ClientStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
+    return self.makeClientStreamingCall(
+      path: "/MyGame.Example.MonsterStorage/GetMaxHitPoint",
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? []
+    )
+  }
+
+  public func GetMinMaxHitPoints(
+    callOptions: CallOptions? = nil,
+    handler: @escaping (Message<MyGame_Example_Stat> ) -> Void
+  ) -> BidirectionalStreamingCall<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>> {
+    return self.makeBidirectionalStreamingCall(
+      path: "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints",
+      callOptions: callOptions ?? self.defaultCallOptions,
+      interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
+      handler: handler
+    )
+  }
+}
+
+public protocol MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol {
+  /// - Returns: Interceptors to use when invoking 'Store'.
+  func makeStoreInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when invoking 'Retrieve'.
+  func makeRetrieveInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
+
+  /// - Returns: Interceptors to use when invoking 'GetMaxHitPoint'.
+  func makeGetMaxHitPointInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when invoking 'GetMinMaxHitPoints'.
+  func makeGetMinMaxHitPointsInterceptors() -> [ClientInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+}
+
+public final class MyGame_Example_MonsterStorageServiceClient: MyGame_Example_MonsterStorageClientProtocol {
+  public let channel: GRPCChannel
+  public var defaultCallOptions: CallOptions
+  public var interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol?
+
+  public init(
+    channel: GRPCChannel,
+    defaultCallOptions: CallOptions = CallOptions(),
+    interceptors: MyGame_Example_MonsterStorageClientInterceptorFactoryProtocol? = nil
+  ) {
+    self.channel = channel
+    self.defaultCallOptions = defaultCallOptions
+    self.interceptors = interceptors
+  }
+}
+
+public protocol MyGame_Example_MonsterStorageProvider: CallHandlerProvider {
+  var interceptors: MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol? { get }
+  func Store(request: Message<MyGame_Example_Monster>, context: StatusOnlyCallContext) -> EventLoopFuture<Message<MyGame_Example_Stat>>
+  func Retrieve(request: Message<MyGame_Example_Stat>, context: StreamingResponseCallContext<Message<MyGame_Example_Monster>>) -> EventLoopFuture<GRPCStatus>
+  func GetMaxHitPoint(context: UnaryResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
+  func GetMinMaxHitPoints(context: StreamingResponseCallContext<Message<MyGame_Example_Stat>>) -> EventLoopFuture<(StreamEvent<Message<MyGame_Example_Monster>>) -> Void>
+}
+
+public extension MyGame_Example_MonsterStorageProvider {
+
+  var serviceName: Substring { return "MyGame.Example.MonsterStorage" }
+
+  func handle(method name: Substring, context: CallHandlerContext) -> GRPCServerHandlerProtocol? {
+    switch name {
+    case "Store":
+    return UnaryServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
+      interceptors: self.interceptors?.makeStoreInterceptors() ?? [],
+      userFunction: self.Store(request:context:))
+
+    case "Retrieve":
+    return ServerStreamingServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Stat>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Monster>>(),
+      interceptors: self.interceptors?.makeRetrieveInterceptors() ?? [],
+      userFunction: self.Retrieve(request:context:))
+
+    case "GetMaxHitPoint":
+    return ClientStreamingServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
+      interceptors: self.interceptors?.makeGetMaxHitPointInterceptors() ?? [],
+      observerFactory: self.GetMaxHitPoint(context:))
+
+    case "GetMinMaxHitPoints":
+    return BidirectionalStreamingServerHandler(
+      context: context,
+      requestDeserializer: GRPCPayloadDeserializer<Message<MyGame_Example_Monster>>(),
+      responseSerializer: GRPCPayloadSerializer<Message<MyGame_Example_Stat>>(),
+      interceptors: self.interceptors?.makeGetMinMaxHitPointsInterceptors() ?? [],
+      observerFactory: self.GetMinMaxHitPoints(context:))
+
+    default: return nil;
+    }
+  }
+
+}
+
+public protocol MyGame_Example_MonsterStorageServerInterceptorFactoryProtocol {
+  /// - Returns: Interceptors to use when handling 'Store'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeStoreInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when handling 'Retrieve'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeRetrieveInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Stat>, Message<MyGame_Example_Monster>>]
+
+  /// - Returns: Interceptors to use when handling 'GetMaxHitPoint'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeGetMaxHitPointInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+  /// - Returns: Interceptors to use when handling 'GetMinMaxHitPoints'.
+  ///   Defaults to calling `self.makeInterceptors()`.
+  func makeGetMinMaxHitPointsInterceptors() -> [ServerInterceptor<Message<MyGame_Example_Monster>, Message<MyGame_Example_Stat>>]
+
+}
+#endif
+

tests/swift/Tests/Flatbuffers/more_defaults_generated.swift

@@ -0,0 +1,223 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public enum ABC: Int32, Enum, Verifiable {
+  public typealias T = Int32
+  public static var byteSize: Int { return MemoryLayout<Int32>.size }
+  public var value: Int32 { return self.rawValue }
+  case a = 0
+  case b = 1
+  case c = 2
+
+  public static var max: ABC { return .c }
+  public static var min: ABC { return .a }
+}
+
+extension ABC: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .a: try container.encode("A")
+    case .b: try container.encode("B")
+    case .c: try container.encode("C")
+    }
+  }
+}
+
+public struct MoreDefaults: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case ints = 4
+    case floats = 6
+    case emptyString = 8
+    case someString = 10
+    case abcs = 12
+    case bools = 14
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var hasInts: Bool { let o = _accessor.offset(VTOFFSET.ints.v); return o == 0 ? false : true }
+  public var intsCount: Int32 { let o = _accessor.offset(VTOFFSET.ints.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func ints(at index: Int32) -> Int32 { let o = _accessor.offset(VTOFFSET.ints.v); return o == 0 ? 0 : _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4) }
+  public var ints: [Int32] { return _accessor.getVector(at: VTOFFSET.ints.v) ?? [] }
+  public func withUnsafePointerToInts<T>(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.ints.v, body: body) }
+  public var hasFloats: Bool { let o = _accessor.offset(VTOFFSET.floats.v); return o == 0 ? false : true }
+  public var floatsCount: Int32 { let o = _accessor.offset(VTOFFSET.floats.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func floats(at index: Int32) -> Float32 { let o = _accessor.offset(VTOFFSET.floats.v); return o == 0 ? 0 : _accessor.directRead(of: Float32.self, offset: _accessor.vector(at: o) + index * 4) }
+  public var floats: [Float32] { return _accessor.getVector(at: VTOFFSET.floats.v) ?? [] }
+  public func withUnsafePointerToFloats<T>(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.floats.v, body: body) }
+  public var emptyString: String? { let o = _accessor.offset(VTOFFSET.emptyString.v); return o == 0 ? "" : _accessor.string(at: o) }
+  public var emptyStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.emptyString.v) }
+  public var someString: String? { let o = _accessor.offset(VTOFFSET.someString.v); return o == 0 ? "some" : _accessor.string(at: o) }
+  public var someStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.someString.v) }
+  public var hasAbcs: Bool { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? false : true }
+  public var abcsCount: Int32 { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func abcs(at index: Int32) -> ABC? { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? ABC.a : ABC(rawValue: _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4)) }
+  public var hasBools: Bool { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? false : true }
+  public var boolsCount: Int32 { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func bools(at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? true : _accessor.directRead(of: Bool.self, offset: _accessor.vector(at: o) + index * 1) }
+  public var bools: [Bool] { return _accessor.getVector(at: VTOFFSET.bools.v) ?? [] }
+  public func withUnsafePointerToBools<T>(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.bools.v, body: body) }
+  public static func startMoreDefaults(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 6) }
+  public static func addVectorOf(ints: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: ints, at: VTOFFSET.ints.p) }
+  public static func addVectorOf(floats: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: floats, at: VTOFFSET.floats.p) }
+  public static func add(emptyString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: emptyString, at: VTOFFSET.emptyString.p) }
+  public static func add(someString: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: someString, at: VTOFFSET.someString.p) }
+  public static func addVectorOf(abcs: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: abcs, at: VTOFFSET.abcs.p) }
+  public static func addVectorOf(bools: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: bools, at: VTOFFSET.bools.p) }
+  public static func endMoreDefaults(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createMoreDefaults(
+    _ fbb: inout FlatBufferBuilder,
+    intsVectorOffset ints: Offset = Offset(),
+    floatsVectorOffset floats: Offset = Offset(),
+    emptyStringOffset emptyString: Offset = Offset(),
+    someStringOffset someString: Offset = Offset(),
+    abcsVectorOffset abcs: Offset = Offset(),
+    boolsVectorOffset bools: Offset = Offset()
+  ) -> Offset {
+    let __start = MoreDefaults.startMoreDefaults(&fbb)
+    MoreDefaults.addVectorOf(ints: ints, &fbb)
+    MoreDefaults.addVectorOf(floats: floats, &fbb)
+    MoreDefaults.add(emptyString: emptyString, &fbb)
+    MoreDefaults.add(someString: someString, &fbb)
+    MoreDefaults.addVectorOf(abcs: abcs, &fbb)
+    MoreDefaults.addVectorOf(bools: bools, &fbb)
+    return MoreDefaults.endMoreDefaults(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> MoreDefaultsT {
+    return MoreDefaultsT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MoreDefaultsT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MoreDefaultsT) -> Offset {
+    let __ints = builder.createVector(obj.ints)
+    let __floats = builder.createVector(obj.floats)
+    let __emptyString: Offset
+    if let s = obj.emptyString {
+      __emptyString = builder.create(string: s)
+    } else {
+      __emptyString = Offset()
+    }
+
+    let __someString: Offset
+    if let s = obj.someString {
+      __someString = builder.create(string: s)
+    } else {
+      __someString = Offset()
+    }
+
+    let __abcs = builder.createVector(obj.abcs)
+    let __bools = builder.createVector(obj.bools)
+    let __root = MoreDefaults.startMoreDefaults(&builder)
+    MoreDefaults.addVectorOf(ints: __ints, &builder)
+    MoreDefaults.addVectorOf(floats: __floats, &builder)
+    MoreDefaults.add(emptyString: __emptyString, &builder)
+    MoreDefaults.add(someString: __someString, &builder)
+    MoreDefaults.addVectorOf(abcs: __abcs, &builder)
+    MoreDefaults.addVectorOf(bools: __bools, &builder)
+    return MoreDefaults.endMoreDefaults(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.ints.p, fieldName: "ints", required: false, type: ForwardOffset<Vector<Int32, Int32>>.self)
+    try _v.visit(field: VTOFFSET.floats.p, fieldName: "floats", required: false, type: ForwardOffset<Vector<Float32, Float32>>.self)
+    try _v.visit(field: VTOFFSET.emptyString.p, fieldName: "emptyString", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.someString.p, fieldName: "someString", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VTOFFSET.abcs.p, fieldName: "abcs", required: false, type: ForwardOffset<Vector<ABC, ABC>>.self)
+    try _v.visit(field: VTOFFSET.bools.p, fieldName: "bools", required: false, type: ForwardOffset<Vector<Bool, Bool>>.self)
+    _v.finish()
+  }
+}
+
+extension MoreDefaults: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case ints = "ints"
+    case floats = "floats"
+    case emptyString = "empty_string"
+    case someString = "some_string"
+    case abcs = "abcs"
+    case bools = "bools"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if intsCount > 0 {
+      try container.encodeIfPresent(ints, forKey: .ints)
+    }
+    if floatsCount > 0 {
+      try container.encodeIfPresent(floats, forKey: .floats)
+    }
+    try container.encodeIfPresent(emptyString, forKey: .emptyString)
+    try container.encodeIfPresent(someString, forKey: .someString)
+    if abcsCount > 0 {
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .abcs)
+      for index in 0..<abcsCount {
+        guard let type = abcs(at: index) else { continue }
+        try contentEncoder.encode(type)
+      }
+    }
+    if boolsCount > 0 {
+      try container.encodeIfPresent(bools, forKey: .bools)
+    }
+  }
+}
+
+public class MoreDefaultsT: NativeObject {
+
+  public var ints: [Int32]
+  public var floats: [Float32]
+  public var emptyString: String?
+  public var someString: String?
+  public var abcs: [ABC]
+  public var bools: [Bool]
+
+  public init(_ _t: inout MoreDefaults) {
+    ints = []
+    for index in 0..<_t.intsCount {
+        ints.append(_t.ints(at: index))
+    }
+    floats = []
+    for index in 0..<_t.floatsCount {
+        floats.append(_t.floats(at: index))
+    }
+    emptyString = _t.emptyString
+    someString = _t.someString
+    abcs = []
+    for index in 0..<_t.abcsCount {
+        abcs.append(_t.abcs(at: index)!)
+    }
+    bools = []
+    for index in 0..<_t.boolsCount {
+        bools.append(_t.bools(at: index))
+    }
+  }
+
+  public init() {
+    ints = []
+    floats = []
+    emptyString = ""
+    someString = "some"
+    abcs = []
+    bools = []
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: MoreDefaults.self) }
+
+}

tests/swift/Tests/Flatbuffers/nan_inf_test_generated.swift

@@ -0,0 +1,114 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public struct Swift_Tests_NanInfTable: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case defaultNan = 4
+    case defaultInf = 6
+    case defaultNinf = 8
+    case valueNan = 10
+    case valueInf = 12
+    case valueNinf = 14
+    case value = 16
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var defaultNan: Double { let o = _accessor.offset(VTOFFSET.defaultNan.v); return o == 0 ? .nan : _accessor.readBuffer(of: Double.self, at: o) }
+  public var defaultInf: Double { let o = _accessor.offset(VTOFFSET.defaultInf.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  public var defaultNinf: Double { let o = _accessor.offset(VTOFFSET.defaultNinf.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueNan: Double { let o = _accessor.offset(VTOFFSET.valueNan.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueInf: Double { let o = _accessor.offset(VTOFFSET.valueInf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueNinf: Double { let o = _accessor.offset(VTOFFSET.valueNinf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var value: Double { let o = _accessor.offset(VTOFFSET.value.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public static func startNanInfTable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 7) }
+  public static func add(defaultNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNan, def: .nan, at: VTOFFSET.defaultNan.p) }
+  public static func add(defaultInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultInf, def: .infinity, at: VTOFFSET.defaultInf.p) }
+  public static func add(defaultNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNinf, def: -.infinity, at: VTOFFSET.defaultNinf.p) }
+  public static func add(valueNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNan, def: 0.0, at: VTOFFSET.valueNan.p) }
+  public static func add(valueInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueInf, def: 0.0, at: VTOFFSET.valueInf.p) }
+  public static func add(valueNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNinf, def: 0.0, at: VTOFFSET.valueNinf.p) }
+  public static func add(value: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: value, def: 0.0, at: VTOFFSET.value.p) }
+  public static func endNanInfTable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createNanInfTable(
+    _ fbb: inout FlatBufferBuilder,
+    defaultNan: Double = .nan,
+    defaultInf: Double = .infinity,
+    defaultNinf: Double = -.infinity,
+    valueNan: Double = 0.0,
+    valueInf: Double = 0.0,
+    valueNinf: Double = 0.0,
+    value: Double = 0.0
+  ) -> Offset {
+    let __start = Swift_Tests_NanInfTable.startNanInfTable(&fbb)
+    Swift_Tests_NanInfTable.add(defaultNan: defaultNan, &fbb)
+    Swift_Tests_NanInfTable.add(defaultInf: defaultInf, &fbb)
+    Swift_Tests_NanInfTable.add(defaultNinf: defaultNinf, &fbb)
+    Swift_Tests_NanInfTable.add(valueNan: valueNan, &fbb)
+    Swift_Tests_NanInfTable.add(valueInf: valueInf, &fbb)
+    Swift_Tests_NanInfTable.add(valueNinf: valueNinf, &fbb)
+    Swift_Tests_NanInfTable.add(value: value, &fbb)
+    return Swift_Tests_NanInfTable.endNanInfTable(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.defaultNan.p, fieldName: "defaultNan", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultInf.p, fieldName: "defaultInf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultNinf.p, fieldName: "defaultNinf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueNan.p, fieldName: "valueNan", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueInf.p, fieldName: "valueInf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueNinf.p, fieldName: "valueNinf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.value.p, fieldName: "value", required: false, type: Double.self)
+    _v.finish()
+  }
+}
+
+extension Swift_Tests_NanInfTable: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case defaultNan = "default_nan"
+    case defaultInf = "default_inf"
+    case defaultNinf = "default_ninf"
+    case valueNan = "value_nan"
+    case valueInf = "value_inf"
+    case valueNinf = "value_ninf"
+    case value = "value"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if !defaultNan.isNaN {
+      try container.encodeIfPresent(defaultNan, forKey: .defaultNan)
+    }
+    if defaultInf != .infinity {
+      try container.encodeIfPresent(defaultInf, forKey: .defaultInf)
+    }
+    if defaultNinf != -.infinity {
+      try container.encodeIfPresent(defaultNinf, forKey: .defaultNinf)
+    }
+    if valueNan != 0.0 {
+      try container.encodeIfPresent(valueNan, forKey: .valueNan)
+    }
+    if valueInf != 0.0 {
+      try container.encodeIfPresent(valueInf, forKey: .valueInf)
+    }
+    if valueNinf != 0.0 {
+      try container.encodeIfPresent(valueNinf, forKey: .valueNinf)
+    }
+    if value != 0.0 {
+      try container.encodeIfPresent(value, forKey: .value)
+    }
+  }
+}
+

tests/swift/Tests/Flatbuffers/optional_scalars_generated.swift

@@ -0,0 +1,407 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public enum optional_scalars_OptionalByte: Int8, Enum, Verifiable {
+  public typealias T = Int8
+  public static var byteSize: Int { return MemoryLayout<Int8>.size }
+  public var value: Int8 { return self.rawValue }
+  case none_ = 0
+  case one = 1
+  case two = 2
+
+  public static var max: optional_scalars_OptionalByte { return .two }
+  public static var min: optional_scalars_OptionalByte { return .none_ }
+}
+
+extension optional_scalars_OptionalByte: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("None")
+    case .one: try container.encode("One")
+    case .two: try container.encode("Two")
+    }
+  }
+}
+
+public struct optional_scalars_ScalarStuff: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static var id: String { "NULL" } 
+  public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: optional_scalars_ScalarStuff.id, addPrefix: prefix) }
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case justI8 = 4
+    case maybeI8 = 6
+    case defaultI8 = 8
+    case justU8 = 10
+    case maybeU8 = 12
+    case defaultU8 = 14
+    case justI16 = 16
+    case maybeI16 = 18
+    case defaultI16 = 20
+    case justU16 = 22
+    case maybeU16 = 24
+    case defaultU16 = 26
+    case justI32 = 28
+    case maybeI32 = 30
+    case defaultI32 = 32
+    case justU32 = 34
+    case maybeU32 = 36
+    case defaultU32 = 38
+    case justI64 = 40
+    case maybeI64 = 42
+    case defaultI64 = 44
+    case justU64 = 46
+    case maybeU64 = 48
+    case defaultU64 = 50
+    case justF32 = 52
+    case maybeF32 = 54
+    case defaultF32 = 56
+    case justF64 = 58
+    case maybeF64 = 60
+    case defaultF64 = 62
+    case justBool = 64
+    case maybeBool = 66
+    case defaultBool = 68
+    case justEnum = 70
+    case maybeEnum = 72
+    case defaultEnum = 74
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var justI8: Int8 { let o = _accessor.offset(VTOFFSET.justI8.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
+  public var maybeI8: Int8? { let o = _accessor.offset(VTOFFSET.maybeI8.v); return o == 0 ? nil : _accessor.readBuffer(of: Int8.self, at: o) }
+  public var defaultI8: Int8 { let o = _accessor.offset(VTOFFSET.defaultI8.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int8.self, at: o) }
+  public var justU8: UInt8 { let o = _accessor.offset(VTOFFSET.justU8.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
+  public var maybeU8: UInt8? { let o = _accessor.offset(VTOFFSET.maybeU8.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt8.self, at: o) }
+  public var defaultU8: UInt8 { let o = _accessor.offset(VTOFFSET.defaultU8.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt8.self, at: o) }
+  public var justI16: Int16 { let o = _accessor.offset(VTOFFSET.justI16.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
+  public var maybeI16: Int16? { let o = _accessor.offset(VTOFFSET.maybeI16.v); return o == 0 ? nil : _accessor.readBuffer(of: Int16.self, at: o) }
+  public var defaultI16: Int16 { let o = _accessor.offset(VTOFFSET.defaultI16.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int16.self, at: o) }
+  public var justU16: UInt16 { let o = _accessor.offset(VTOFFSET.justU16.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
+  public var maybeU16: UInt16? { let o = _accessor.offset(VTOFFSET.maybeU16.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt16.self, at: o) }
+  public var defaultU16: UInt16 { let o = _accessor.offset(VTOFFSET.defaultU16.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt16.self, at: o) }
+  public var justI32: Int32 { let o = _accessor.offset(VTOFFSET.justI32.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+  public var maybeI32: Int32? { let o = _accessor.offset(VTOFFSET.maybeI32.v); return o == 0 ? nil : _accessor.readBuffer(of: Int32.self, at: o) }
+  public var defaultI32: Int32 { let o = _accessor.offset(VTOFFSET.defaultI32.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int32.self, at: o) }
+  public var justU32: UInt32 { let o = _accessor.offset(VTOFFSET.justU32.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
+  public var maybeU32: UInt32? { let o = _accessor.offset(VTOFFSET.maybeU32.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt32.self, at: o) }
+  public var defaultU32: UInt32 { let o = _accessor.offset(VTOFFSET.defaultU32.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt32.self, at: o) }
+  public var justI64: Int64 { let o = _accessor.offset(VTOFFSET.justI64.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+  public var maybeI64: Int64? { let o = _accessor.offset(VTOFFSET.maybeI64.v); return o == 0 ? nil : _accessor.readBuffer(of: Int64.self, at: o) }
+  public var defaultI64: Int64 { let o = _accessor.offset(VTOFFSET.defaultI64.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int64.self, at: o) }
+  public var justU64: UInt64 { let o = _accessor.offset(VTOFFSET.justU64.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+  public var maybeU64: UInt64? { let o = _accessor.offset(VTOFFSET.maybeU64.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt64.self, at: o) }
+  public var defaultU64: UInt64 { let o = _accessor.offset(VTOFFSET.defaultU64.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt64.self, at: o) }
+  public var justF32: Float32 { let o = _accessor.offset(VTOFFSET.justF32.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var maybeF32: Float32? { let o = _accessor.offset(VTOFFSET.maybeF32.v); return o == 0 ? nil : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var defaultF32: Float32 { let o = _accessor.offset(VTOFFSET.defaultF32.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var justF64: Double { let o = _accessor.offset(VTOFFSET.justF64.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var maybeF64: Double? { let o = _accessor.offset(VTOFFSET.maybeF64.v); return o == 0 ? nil : _accessor.readBuffer(of: Double.self, at: o) }
+  public var defaultF64: Double { let o = _accessor.offset(VTOFFSET.defaultF64.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var justBool: Bool { let o = _accessor.offset(VTOFFSET.justBool.v); return o == 0 ? false : _accessor.readBuffer(of: Bool.self, at: o) }
+  public var maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? nil : _accessor.readBuffer(of: Bool.self, at: o) }
+  public var defaultBool: Bool { let o = _accessor.offset(VTOFFSET.defaultBool.v); return o == 0 ? true : _accessor.readBuffer(of: Bool.self, at: o) }
+  public var justEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.justEnum.v); return o == 0 ? .none_ : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
+  public var maybeEnum: optional_scalars_OptionalByte? { let o = _accessor.offset(VTOFFSET.maybeEnum.v); return o == 0 ? nil : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? nil }
+  public var defaultEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.defaultEnum.v); return o == 0 ? .one : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .one }
+  public static func startScalarStuff(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 36) }
+  public static func add(justI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI8, def: 0, at: VTOFFSET.justI8.p) }
+  public static func add(maybeI8: Int8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI8, at: VTOFFSET.maybeI8.p) }
+  public static func add(defaultI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI8, def: 42, at: VTOFFSET.defaultI8.p) }
+  public static func add(justU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU8, def: 0, at: VTOFFSET.justU8.p) }
+  public static func add(maybeU8: UInt8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU8, at: VTOFFSET.maybeU8.p) }
+  public static func add(defaultU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU8, def: 42, at: VTOFFSET.defaultU8.p) }
+  public static func add(justI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI16, def: 0, at: VTOFFSET.justI16.p) }
+  public static func add(maybeI16: Int16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI16, at: VTOFFSET.maybeI16.p) }
+  public static func add(defaultI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI16, def: 42, at: VTOFFSET.defaultI16.p) }
+  public static func add(justU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU16, def: 0, at: VTOFFSET.justU16.p) }
+  public static func add(maybeU16: UInt16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU16, at: VTOFFSET.maybeU16.p) }
+  public static func add(defaultU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU16, def: 42, at: VTOFFSET.defaultU16.p) }
+  public static func add(justI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI32, def: 0, at: VTOFFSET.justI32.p) }
+  public static func add(maybeI32: Int32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI32, at: VTOFFSET.maybeI32.p) }
+  public static func add(defaultI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI32, def: 42, at: VTOFFSET.defaultI32.p) }
+  public static func add(justU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU32, def: 0, at: VTOFFSET.justU32.p) }
+  public static func add(maybeU32: UInt32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU32, at: VTOFFSET.maybeU32.p) }
+  public static func add(defaultU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU32, def: 42, at: VTOFFSET.defaultU32.p) }
+  public static func add(justI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI64, def: 0, at: VTOFFSET.justI64.p) }
+  public static func add(maybeI64: Int64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI64, at: VTOFFSET.maybeI64.p) }
+  public static func add(defaultI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI64, def: 42, at: VTOFFSET.defaultI64.p) }
+  public static func add(justU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU64, def: 0, at: VTOFFSET.justU64.p) }
+  public static func add(maybeU64: UInt64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU64, at: VTOFFSET.maybeU64.p) }
+  public static func add(defaultU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU64, def: 42, at: VTOFFSET.defaultU64.p) }
+  public static func add(justF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF32, def: 0.0, at: VTOFFSET.justF32.p) }
+  public static func add(maybeF32: Float32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF32, at: VTOFFSET.maybeF32.p) }
+  public static func add(defaultF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF32, def: 42.0, at: VTOFFSET.defaultF32.p) }
+  public static func add(justF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF64, def: 0.0, at: VTOFFSET.justF64.p) }
+  public static func add(maybeF64: Double?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF64, at: VTOFFSET.maybeF64.p) }
+  public static func add(defaultF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF64, def: 42.0, at: VTOFFSET.defaultF64.p) }
+  public static func add(justBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justBool, def: false,
+   at: VTOFFSET.justBool.p) }
+  public static func add(maybeBool: Bool?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeBool, at: VTOFFSET.maybeBool.p) }
+  public static func add(defaultBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultBool, def: true,
+   at: VTOFFSET.defaultBool.p) }
+  public static func add(justEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justEnum.rawValue, def: 0, at: VTOFFSET.justEnum.p) }
+  public static func add(maybeEnum: optional_scalars_OptionalByte?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeEnum?.rawValue, at: VTOFFSET.maybeEnum.p) }
+  public static func add(defaultEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultEnum.rawValue, def: 1, at: VTOFFSET.defaultEnum.p) }
+  public static func endScalarStuff(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createScalarStuff(
+    _ fbb: inout FlatBufferBuilder,
+    justI8: Int8 = 0,
+    maybeI8: Int8? = nil,
+    defaultI8: Int8 = 42,
+    justU8: UInt8 = 0,
+    maybeU8: UInt8? = nil,
+    defaultU8: UInt8 = 42,
+    justI16: Int16 = 0,
+    maybeI16: Int16? = nil,
+    defaultI16: Int16 = 42,
+    justU16: UInt16 = 0,
+    maybeU16: UInt16? = nil,
+    defaultU16: UInt16 = 42,
+    justI32: Int32 = 0,
+    maybeI32: Int32? = nil,
+    defaultI32: Int32 = 42,
+    justU32: UInt32 = 0,
+    maybeU32: UInt32? = nil,
+    defaultU32: UInt32 = 42,
+    justI64: Int64 = 0,
+    maybeI64: Int64? = nil,
+    defaultI64: Int64 = 42,
+    justU64: UInt64 = 0,
+    maybeU64: UInt64? = nil,
+    defaultU64: UInt64 = 42,
+    justF32: Float32 = 0.0,
+    maybeF32: Float32? = nil,
+    defaultF32: Float32 = 42.0,
+    justF64: Double = 0.0,
+    maybeF64: Double? = nil,
+    defaultF64: Double = 42.0,
+    justBool: Bool = false,
+    maybeBool: Bool? = nil,
+    defaultBool: Bool = true,
+    justEnum: optional_scalars_OptionalByte = .none_,
+    maybeEnum: optional_scalars_OptionalByte? = nil,
+    defaultEnum: optional_scalars_OptionalByte = .one
+  ) -> Offset {
+    let __start = optional_scalars_ScalarStuff.startScalarStuff(&fbb)
+    optional_scalars_ScalarStuff.add(justI8: justI8, &fbb)
+    optional_scalars_ScalarStuff.add(maybeI8: maybeI8, &fbb)
+    optional_scalars_ScalarStuff.add(defaultI8: defaultI8, &fbb)
+    optional_scalars_ScalarStuff.add(justU8: justU8, &fbb)
+    optional_scalars_ScalarStuff.add(maybeU8: maybeU8, &fbb)
+    optional_scalars_ScalarStuff.add(defaultU8: defaultU8, &fbb)
+    optional_scalars_ScalarStuff.add(justI16: justI16, &fbb)
+    optional_scalars_ScalarStuff.add(maybeI16: maybeI16, &fbb)
+    optional_scalars_ScalarStuff.add(defaultI16: defaultI16, &fbb)
+    optional_scalars_ScalarStuff.add(justU16: justU16, &fbb)
+    optional_scalars_ScalarStuff.add(maybeU16: maybeU16, &fbb)
+    optional_scalars_ScalarStuff.add(defaultU16: defaultU16, &fbb)
+    optional_scalars_ScalarStuff.add(justI32: justI32, &fbb)
+    optional_scalars_ScalarStuff.add(maybeI32: maybeI32, &fbb)
+    optional_scalars_ScalarStuff.add(defaultI32: defaultI32, &fbb)
+    optional_scalars_ScalarStuff.add(justU32: justU32, &fbb)
+    optional_scalars_ScalarStuff.add(maybeU32: maybeU32, &fbb)
+    optional_scalars_ScalarStuff.add(defaultU32: defaultU32, &fbb)
+    optional_scalars_ScalarStuff.add(justI64: justI64, &fbb)
+    optional_scalars_ScalarStuff.add(maybeI64: maybeI64, &fbb)
+    optional_scalars_ScalarStuff.add(defaultI64: defaultI64, &fbb)
+    optional_scalars_ScalarStuff.add(justU64: justU64, &fbb)
+    optional_scalars_ScalarStuff.add(maybeU64: maybeU64, &fbb)
+    optional_scalars_ScalarStuff.add(defaultU64: defaultU64, &fbb)
+    optional_scalars_ScalarStuff.add(justF32: justF32, &fbb)
+    optional_scalars_ScalarStuff.add(maybeF32: maybeF32, &fbb)
+    optional_scalars_ScalarStuff.add(defaultF32: defaultF32, &fbb)
+    optional_scalars_ScalarStuff.add(justF64: justF64, &fbb)
+    optional_scalars_ScalarStuff.add(maybeF64: maybeF64, &fbb)
+    optional_scalars_ScalarStuff.add(defaultF64: defaultF64, &fbb)
+    optional_scalars_ScalarStuff.add(justBool: justBool, &fbb)
+    optional_scalars_ScalarStuff.add(maybeBool: maybeBool, &fbb)
+    optional_scalars_ScalarStuff.add(defaultBool: defaultBool, &fbb)
+    optional_scalars_ScalarStuff.add(justEnum: justEnum, &fbb)
+    optional_scalars_ScalarStuff.add(maybeEnum: maybeEnum, &fbb)
+    optional_scalars_ScalarStuff.add(defaultEnum: defaultEnum, &fbb)
+    return optional_scalars_ScalarStuff.endScalarStuff(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.justI8.p, fieldName: "justI8", required: false, type: Int8.self)
+    try _v.visit(field: VTOFFSET.maybeI8.p, fieldName: "maybeI8", required: false, type: Int8.self)
+    try _v.visit(field: VTOFFSET.defaultI8.p, fieldName: "defaultI8", required: false, type: Int8.self)
+    try _v.visit(field: VTOFFSET.justU8.p, fieldName: "justU8", required: false, type: UInt8.self)
+    try _v.visit(field: VTOFFSET.maybeU8.p, fieldName: "maybeU8", required: false, type: UInt8.self)
+    try _v.visit(field: VTOFFSET.defaultU8.p, fieldName: "defaultU8", required: false, type: UInt8.self)
+    try _v.visit(field: VTOFFSET.justI16.p, fieldName: "justI16", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.maybeI16.p, fieldName: "maybeI16", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.defaultI16.p, fieldName: "defaultI16", required: false, type: Int16.self)
+    try _v.visit(field: VTOFFSET.justU16.p, fieldName: "justU16", required: false, type: UInt16.self)
+    try _v.visit(field: VTOFFSET.maybeU16.p, fieldName: "maybeU16", required: false, type: UInt16.self)
+    try _v.visit(field: VTOFFSET.defaultU16.p, fieldName: "defaultU16", required: false, type: UInt16.self)
+    try _v.visit(field: VTOFFSET.justI32.p, fieldName: "justI32", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.maybeI32.p, fieldName: "maybeI32", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.defaultI32.p, fieldName: "defaultI32", required: false, type: Int32.self)
+    try _v.visit(field: VTOFFSET.justU32.p, fieldName: "justU32", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.maybeU32.p, fieldName: "maybeU32", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.defaultU32.p, fieldName: "defaultU32", required: false, type: UInt32.self)
+    try _v.visit(field: VTOFFSET.justI64.p, fieldName: "justI64", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.maybeI64.p, fieldName: "maybeI64", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.defaultI64.p, fieldName: "defaultI64", required: false, type: Int64.self)
+    try _v.visit(field: VTOFFSET.justU64.p, fieldName: "justU64", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.maybeU64.p, fieldName: "maybeU64", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.defaultU64.p, fieldName: "defaultU64", required: false, type: UInt64.self)
+    try _v.visit(field: VTOFFSET.justF32.p, fieldName: "justF32", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.maybeF32.p, fieldName: "maybeF32", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.defaultF32.p, fieldName: "defaultF32", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.justF64.p, fieldName: "justF64", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.maybeF64.p, fieldName: "maybeF64", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultF64.p, fieldName: "defaultF64", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.justBool.p, fieldName: "justBool", required: false, type: Bool.self)
+    try _v.visit(field: VTOFFSET.maybeBool.p, fieldName: "maybeBool", required: false, type: Bool.self)
+    try _v.visit(field: VTOFFSET.defaultBool.p, fieldName: "defaultBool", required: false, type: Bool.self)
+    try _v.visit(field: VTOFFSET.justEnum.p, fieldName: "justEnum", required: false, type: optional_scalars_OptionalByte.self)
+    try _v.visit(field: VTOFFSET.maybeEnum.p, fieldName: "maybeEnum", required: false, type: optional_scalars_OptionalByte.self)
+    try _v.visit(field: VTOFFSET.defaultEnum.p, fieldName: "defaultEnum", required: false, type: optional_scalars_OptionalByte.self)
+    _v.finish()
+  }
+}
+
+extension optional_scalars_ScalarStuff: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case justI8 = "just_i8"
+    case maybeI8 = "maybe_i8"
+    case defaultI8 = "default_i8"
+    case justU8 = "just_u8"
+    case maybeU8 = "maybe_u8"
+    case defaultU8 = "default_u8"
+    case justI16 = "just_i16"
+    case maybeI16 = "maybe_i16"
+    case defaultI16 = "default_i16"
+    case justU16 = "just_u16"
+    case maybeU16 = "maybe_u16"
+    case defaultU16 = "default_u16"
+    case justI32 = "just_i32"
+    case maybeI32 = "maybe_i32"
+    case defaultI32 = "default_i32"
+    case justU32 = "just_u32"
+    case maybeU32 = "maybe_u32"
+    case defaultU32 = "default_u32"
+    case justI64 = "just_i64"
+    case maybeI64 = "maybe_i64"
+    case defaultI64 = "default_i64"
+    case justU64 = "just_u64"
+    case maybeU64 = "maybe_u64"
+    case defaultU64 = "default_u64"
+    case justF32 = "just_f32"
+    case maybeF32 = "maybe_f32"
+    case defaultF32 = "default_f32"
+    case justF64 = "just_f64"
+    case maybeF64 = "maybe_f64"
+    case defaultF64 = "default_f64"
+    case justBool = "just_bool"
+    case maybeBool = "maybe_bool"
+    case defaultBool = "default_bool"
+    case justEnum = "just_enum"
+    case maybeEnum = "maybe_enum"
+    case defaultEnum = "default_enum"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if justI8 != 0 {
+      try container.encodeIfPresent(justI8, forKey: .justI8)
+    }
+    try container.encodeIfPresent(maybeI8, forKey: .maybeI8)
+    if defaultI8 != 42 {
+      try container.encodeIfPresent(defaultI8, forKey: .defaultI8)
+    }
+    if justU8 != 0 {
+      try container.encodeIfPresent(justU8, forKey: .justU8)
+    }
+    try container.encodeIfPresent(maybeU8, forKey: .maybeU8)
+    if defaultU8 != 42 {
+      try container.encodeIfPresent(defaultU8, forKey: .defaultU8)
+    }
+    if justI16 != 0 {
+      try container.encodeIfPresent(justI16, forKey: .justI16)
+    }
+    try container.encodeIfPresent(maybeI16, forKey: .maybeI16)
+    if defaultI16 != 42 {
+      try container.encodeIfPresent(defaultI16, forKey: .defaultI16)
+    }
+    if justU16 != 0 {
+      try container.encodeIfPresent(justU16, forKey: .justU16)
+    }
+    try container.encodeIfPresent(maybeU16, forKey: .maybeU16)
+    if defaultU16 != 42 {
+      try container.encodeIfPresent(defaultU16, forKey: .defaultU16)
+    }
+    if justI32 != 0 {
+      try container.encodeIfPresent(justI32, forKey: .justI32)
+    }
+    try container.encodeIfPresent(maybeI32, forKey: .maybeI32)
+    if defaultI32 != 42 {
+      try container.encodeIfPresent(defaultI32, forKey: .defaultI32)
+    }
+    if justU32 != 0 {
+      try container.encodeIfPresent(justU32, forKey: .justU32)
+    }
+    try container.encodeIfPresent(maybeU32, forKey: .maybeU32)
+    if defaultU32 != 42 {
+      try container.encodeIfPresent(defaultU32, forKey: .defaultU32)
+    }
+    if justI64 != 0 {
+      try container.encodeIfPresent(justI64, forKey: .justI64)
+    }
+    try container.encodeIfPresent(maybeI64, forKey: .maybeI64)
+    if defaultI64 != 42 {
+      try container.encodeIfPresent(defaultI64, forKey: .defaultI64)
+    }
+    if justU64 != 0 {
+      try container.encodeIfPresent(justU64, forKey: .justU64)
+    }
+    try container.encodeIfPresent(maybeU64, forKey: .maybeU64)
+    if defaultU64 != 42 {
+      try container.encodeIfPresent(defaultU64, forKey: .defaultU64)
+    }
+    if justF32 != 0.0 {
+      try container.encodeIfPresent(justF32, forKey: .justF32)
+    }
+    try container.encodeIfPresent(maybeF32, forKey: .maybeF32)
+    if defaultF32 != 42.0 {
+      try container.encodeIfPresent(defaultF32, forKey: .defaultF32)
+    }
+    if justF64 != 0.0 {
+      try container.encodeIfPresent(justF64, forKey: .justF64)
+    }
+    try container.encodeIfPresent(maybeF64, forKey: .maybeF64)
+    if defaultF64 != 42.0 {
+      try container.encodeIfPresent(defaultF64, forKey: .defaultF64)
+    }
+    if justBool != false {
+      try container.encodeIfPresent(justBool, forKey: .justBool)
+    }
+    try container.encodeIfPresent(maybeBool, forKey: .maybeBool)
+    if defaultBool != true {
+      try container.encodeIfPresent(defaultBool, forKey: .defaultBool)
+    }
+    if justEnum != .none_ {
+      try container.encodeIfPresent(justEnum, forKey: .justEnum)
+    }
+    try container.encodeIfPresent(maybeEnum, forKey: .maybeEnum)
+    if defaultEnum != .one {
+      try container.encodeIfPresent(defaultEnum, forKey: .defaultEnum)
+    }
+  }
+}
+

tests/swift/Tests/Flatbuffers/union_vector_generated.swift

@@ -0,0 +1,732 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public enum Character: UInt8, UnionEnum {
+  public typealias T = UInt8
+
+  public init?(value: T) {
+    self.init(rawValue: value)
+  }
+
+  public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+  public var value: UInt8 { return self.rawValue }
+  case none_ = 0
+  case mulan = 1
+  case rapunzel = 2
+  case belle = 3
+  case bookfan = 4
+  case other = 5
+  case unused = 6
+
+  public static var max: Character { return .unused }
+  public static var min: Character { return .none_ }
+}
+
+extension Character: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("NONE")
+    case .mulan: try container.encode("MuLan")
+    case .rapunzel: try container.encode("Rapunzel")
+    case .belle: try container.encode("Belle")
+    case .bookfan: try container.encode("BookFan")
+    case .other: try container.encode("Other")
+    case .unused: try container.encode("Unused")
+    }
+  }
+}
+
+public struct CharacterUnion {
+  public var type: Character
+  public var value: NativeObject?
+  public init(_ v: NativeObject?, type: Character) {
+    self.type = type
+    self.value = v
+  }
+  public func pack(builder: inout FlatBufferBuilder) -> Offset {
+    switch type {
+    case .mulan:
+      var __obj = value as? AttackerT
+      return Attacker.pack(&builder, obj: &__obj)
+    case .rapunzel:
+      var __obj = value as? Rapunzel
+      return Rapunzel_Mutable.pack(&builder, obj: &__obj)
+    case .belle:
+      var __obj = value as? BookReader
+      return BookReader_Mutable.pack(&builder, obj: &__obj)
+    case .bookfan:
+      var __obj = value as? BookReader
+      return BookReader_Mutable.pack(&builder, obj: &__obj)
+    case .other:
+      var __obj = value as? String
+      return String.pack(&builder, obj: &__obj)
+    case .unused:
+      var __obj = value as? String
+      return String.pack(&builder, obj: &__obj)
+    default: return Offset()
+    }
+  }
+}
+public enum Gadget: UInt8, UnionEnum {
+  public typealias T = UInt8
+
+  public init?(value: T) {
+    self.init(rawValue: value)
+  }
+
+  public static var byteSize: Int { return MemoryLayout<UInt8>.size }
+  public var value: UInt8 { return self.rawValue }
+  case none_ = 0
+  case fallingtub = 1
+  case handfan = 2
+
+  public static var max: Gadget { return .handfan }
+  public static var min: Gadget { return .none_ }
+}
+
+extension Gadget: Encodable {
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.singleValueContainer()
+    switch self {
+    case .none_: try container.encode("NONE")
+    case .fallingtub: try container.encode("FallingTub")
+    case .handfan: try container.encode("HandFan")
+    }
+  }
+}
+
+public struct GadgetUnion {
+  public var type: Gadget
+  public var value: NativeObject?
+  public init(_ v: NativeObject?, type: Gadget) {
+    self.type = type
+    self.value = v
+  }
+  public func pack(builder: inout FlatBufferBuilder) -> Offset {
+    switch type {
+    case .fallingtub:
+      var __obj = value as? FallingTub
+      return FallingTub_Mutable.pack(&builder, obj: &__obj)
+    case .handfan:
+      var __obj = value as? HandFanT
+      return HandFan.pack(&builder, obj: &__obj)
+    default: return Offset()
+    }
+  }
+}
+public struct Rapunzel: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+
+  private var _hairLength: Int32
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _hairLength = _accessor.readBuffer(of: Int32.self, at: 0)
+  }
+
+  public init(hairLength: Int32) {
+    _hairLength = hairLength
+  }
+
+  public init() {
+    _hairLength = 0
+  }
+
+  public init(_ _t: inout Rapunzel_Mutable) {
+    _hairLength = _t.hairLength
+  }
+
+  public var hairLength: Int32 { _hairLength }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: Rapunzel.self)
+  }
+}
+
+extension Rapunzel: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case hairLength = "hair_length"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if hairLength != 0 {
+      try container.encodeIfPresent(hairLength, forKey: .hairLength)
+    }
+  }
+}
+
+public struct Rapunzel_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Struct
+
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+  public var hairLength: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+  @discardableResult public func mutate(hairLength: Int32) -> Bool { return _accessor.mutate(hairLength, index: 0) }
+  
+
+  public mutating func unpack() -> Rapunzel {
+    return Rapunzel(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Rapunzel?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Rapunzel) -> Offset {
+    return builder.create(struct: obj)
+  }
+}
+
+public struct BookReader: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+
+  private var _booksRead: Int32
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _booksRead = _accessor.readBuffer(of: Int32.self, at: 0)
+  }
+
+  public init(booksRead: Int32) {
+    _booksRead = booksRead
+  }
+
+  public init() {
+    _booksRead = 0
+  }
+
+  public init(_ _t: inout BookReader_Mutable) {
+    _booksRead = _t.booksRead
+  }
+
+  public var booksRead: Int32 { _booksRead }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: BookReader.self)
+  }
+}
+
+extension BookReader: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case booksRead = "books_read"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if booksRead != 0 {
+      try container.encodeIfPresent(booksRead, forKey: .booksRead)
+    }
+  }
+}
+
+public struct BookReader_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Struct
+
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+  public var booksRead: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+  @discardableResult public func mutate(booksRead: Int32) -> Bool { return _accessor.mutate(booksRead, index: 0) }
+  
+
+  public mutating func unpack() -> BookReader {
+    return BookReader(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReader?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReader) -> Offset {
+    return builder.create(struct: obj)
+  }
+}
+
+public struct FallingTub: NativeStruct, Verifiable, FlatbuffersInitializable, NativeObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+
+  private var _weight: Int32
+
+  public init(_ bb: ByteBuffer, o: Int32) {
+    let _accessor = Struct(bb: bb, position: o)
+    _weight = _accessor.readBuffer(of: Int32.self, at: 0)
+  }
+
+  public init(weight: Int32) {
+    _weight = weight
+  }
+
+  public init() {
+    _weight = 0
+  }
+
+  public init(_ _t: inout FallingTub_Mutable) {
+    _weight = _t.weight
+  }
+
+  public var weight: Int32 { _weight }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    try verifier.inBuffer(position: position, of: FallingTub.self)
+  }
+}
+
+extension FallingTub: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case weight = "weight"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if weight != 0 {
+      try container.encodeIfPresent(weight, forKey: .weight)
+    }
+  }
+}
+
+public struct FallingTub_Mutable: FlatBufferObject {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Struct
+
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+
+  public var weight: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+  @discardableResult public func mutate(weight: Int32) -> Bool { return _accessor.mutate(weight, index: 0) }
+  
+
+  public mutating func unpack() -> FallingTub {
+    return FallingTub(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout FallingTub?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout FallingTub) -> Offset {
+    return builder.create(struct: obj)
+  }
+}
+
+public struct Attacker: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static var id: String { "MOVI" } 
+  public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: Attacker.id, addPrefix: prefix) }
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case swordAttackDamage = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var swordAttackDamage: Int32 { let o = _accessor.offset(VTOFFSET.swordAttackDamage.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+  @discardableResult public func mutate(swordAttackDamage: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.swordAttackDamage.v);  return _accessor.mutate(swordAttackDamage, index: o) }
+  public static func startAttacker(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(swordAttackDamage: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: swordAttackDamage, def: 0, at: VTOFFSET.swordAttackDamage.p) }
+  public static func endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createAttacker(
+    _ fbb: inout FlatBufferBuilder,
+    swordAttackDamage: Int32 = 0
+  ) -> Offset {
+    let __start = Attacker.startAttacker(&fbb)
+    Attacker.add(swordAttackDamage: swordAttackDamage, &fbb)
+    return Attacker.endAttacker(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> AttackerT {
+    return AttackerT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT) -> Offset {
+    let __root = Attacker.startAttacker(&builder)
+    Attacker.add(swordAttackDamage: obj.swordAttackDamage, &builder)
+    return Attacker.endAttacker(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.swordAttackDamage.p, fieldName: "swordAttackDamage", required: false, type: Int32.self)
+    _v.finish()
+  }
+}
+
+extension Attacker: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case swordAttackDamage = "sword_attack_damage"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if swordAttackDamage != 0 {
+      try container.encodeIfPresent(swordAttackDamage, forKey: .swordAttackDamage)
+    }
+  }
+}
+
+public class AttackerT: NativeObject {
+
+  public var swordAttackDamage: Int32
+
+  public init(_ _t: inout Attacker) {
+    swordAttackDamage = _t.swordAttackDamage
+  }
+
+  public init() {
+    swordAttackDamage = 0
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
+
+}
+public struct HandFan: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static var id: String { "MOVI" } 
+  public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: HandFan.id, addPrefix: prefix) }
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case length = 4
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var length: Int32 { let o = _accessor.offset(VTOFFSET.length.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+  @discardableResult public func mutate(length: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.length.v);  return _accessor.mutate(length, index: o) }
+  public static func startHandFan(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+  public static func add(length: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: length, def: 0, at: VTOFFSET.length.p) }
+  public static func endHandFan(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createHandFan(
+    _ fbb: inout FlatBufferBuilder,
+    length: Int32 = 0
+  ) -> Offset {
+    let __start = HandFan.startHandFan(&fbb)
+    HandFan.add(length: length, &fbb)
+    return HandFan.endHandFan(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> HandFanT {
+    return HandFanT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout HandFanT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout HandFanT) -> Offset {
+    let __root = HandFan.startHandFan(&builder)
+    HandFan.add(length: obj.length, &builder)
+    return HandFan.endHandFan(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.length.p, fieldName: "length", required: false, type: Int32.self)
+    _v.finish()
+  }
+}
+
+extension HandFan: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case length = "length"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if length != 0 {
+      try container.encodeIfPresent(length, forKey: .length)
+    }
+  }
+}
+
+public class HandFanT: NativeObject {
+
+  public var length: Int32
+
+  public init(_ _t: inout HandFan) {
+    length = _t.length
+  }
+
+  public init() {
+    length = 0
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: HandFan.self) }
+
+}
+public struct Movie: FlatBufferObject, Verifiable, ObjectAPIPacker {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static var id: String { "MOVI" } 
+  public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: Movie.id, addPrefix: prefix) }
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case mainCharacterType = 4
+    case mainCharacter = 6
+    case charactersType = 8
+    case characters = 10
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var mainCharacterType: Character { let o = _accessor.offset(VTOFFSET.mainCharacterType.v); return o == 0 ? .none_ : Character(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+  public func mainCharacter<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.mainCharacter.v); return o == 0 ? nil : _accessor.union(o) }
+  public var hasCharactersType: Bool { let o = _accessor.offset(VTOFFSET.charactersType.v); return o == 0 ? false : true }
+  public var charactersTypeCount: Int32 { let o = _accessor.offset(VTOFFSET.charactersType.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func charactersType(at index: Int32) -> Character? { let o = _accessor.offset(VTOFFSET.charactersType.v); return o == 0 ? Character.none_ : Character(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
+  public var hasCharacters: Bool { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? false : true }
+  public var charactersCount: Int32 { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func characters<T: FlatbuffersInitializable>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? nil : _accessor.directUnion(_accessor.vector(at: o) + index * 4) }
+  public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) }
+  public static func add(mainCharacterType: Character, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mainCharacterType.rawValue, def: 0, at: VTOFFSET.mainCharacterType.p) }
+  public static func add(mainCharacter: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VTOFFSET.mainCharacter.p) }
+  public static func addVectorOf(charactersType: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p) }
+  public static func addVectorOf(characters: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p) }
+  public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createMovie(
+    _ fbb: inout FlatBufferBuilder,
+    mainCharacterType: Character = .none_,
+    mainCharacterOffset mainCharacter: Offset = Offset(),
+    charactersTypeVectorOffset charactersType: Offset = Offset(),
+    charactersVectorOffset characters: Offset = Offset()
+  ) -> Offset {
+    let __start = Movie.startMovie(&fbb)
+    Movie.add(mainCharacterType: mainCharacterType, &fbb)
+    Movie.add(mainCharacter: mainCharacter, &fbb)
+    Movie.addVectorOf(charactersType: charactersType, &fbb)
+    Movie.addVectorOf(characters: characters, &fbb)
+    return Movie.endMovie(&fbb, start: __start)
+  }
+  
+
+  public mutating func unpack() -> MovieT {
+    return MovieT(&self)
+  }
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT?) -> Offset {
+    guard var obj = obj else { return Offset() }
+    return pack(&builder, obj: &obj)
+  }
+
+  public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT) -> Offset {
+    let __mainCharacter = obj.mainCharacter?.pack(builder: &builder) ?? Offset()
+    var __characters__: [Offset] = []
+    for i in obj.characters {
+      guard let off = i?.pack(builder: &builder) else { continue }
+      __characters__.append(off)
+    }
+    let __characters = builder.createVector(ofOffsets: __characters__)
+    let __charactersType = builder.createVector(obj.characters.compactMap { $0?.type })
+    let __root = Movie.startMovie(&builder)
+    if let o = obj.mainCharacter?.type {
+      Movie.add(mainCharacterType: o, &builder)
+      Movie.add(mainCharacter: __mainCharacter, &builder)
+    }
+
+    Movie.addVectorOf(charactersType: __charactersType, &builder)
+    Movie.addVectorOf(characters: __characters, &builder)
+    return Movie.endMovie(&builder, start: __root)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(unionKey: VTOFFSET.mainCharacterType.p, unionField: VTOFFSET.mainCharacter.p, unionKeyName: "mainCharacterType", fieldName: "mainCharacter", required: false, completion: { (verifier, key: Character, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .mulan:
+        try ForwardOffset<Attacker>.verify(&verifier, at: pos, of: Attacker.self)
+      case .rapunzel:
+        try Rapunzel.verify(&verifier, at: pos, of: Rapunzel.self)
+      case .belle:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .bookfan:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .other:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      case .unused:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      }
+    })
+    try _v.visitUnionVector(unionKey: VTOFFSET.charactersType.p, unionField: VTOFFSET.characters.p, unionKeyName: "charactersType", fieldName: "characters", required: false, completion: { (verifier, key: Character, pos) in
+      switch key {
+      case .none_:
+        break // NOTE - SWIFT doesnt support none
+      case .mulan:
+        try ForwardOffset<Attacker>.verify(&verifier, at: pos, of: Attacker.self)
+      case .rapunzel:
+        try Rapunzel.verify(&verifier, at: pos, of: Rapunzel.self)
+      case .belle:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .bookfan:
+        try BookReader.verify(&verifier, at: pos, of: BookReader.self)
+      case .other:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      case .unused:
+        try ForwardOffset<String>.verify(&verifier, at: pos, of: String.self)
+      }
+    })
+    _v.finish()
+  }
+}
+
+extension Movie: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case mainCharacterType = "main_character_type"
+    case mainCharacter = "main_character"
+    case charactersType = "characters_type"
+    case characters = "characters"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if mainCharacterType != .none_ {
+      try container.encodeIfPresent(mainCharacterType, forKey: .mainCharacterType)
+    }
+    switch mainCharacterType {
+    case .mulan:
+      let _v = mainCharacter(type: Attacker.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .rapunzel:
+      let _v = mainCharacter(type: Rapunzel.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .belle:
+      let _v = mainCharacter(type: BookReader.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .bookfan:
+      let _v = mainCharacter(type: BookReader.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .other:
+      let _v = mainCharacter(type: String.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    case .unused:
+      let _v = mainCharacter(type: String.self)
+      try container.encodeIfPresent(_v, forKey: .mainCharacter)
+    default: break;
+    }
+    if charactersCount > 0 {
+      var enumsEncoder = container.nestedUnkeyedContainer(forKey: .charactersType)
+      var contentEncoder = container.nestedUnkeyedContainer(forKey: .characters)
+      for index in 0..<charactersCount {
+        guard let type = charactersType(at: index) else { continue }
+        try enumsEncoder.encode(type)
+        switch type {
+        case .mulan:
+          let _v = characters(at: index, type: Attacker.self)
+          try contentEncoder.encode(_v)
+        case .rapunzel:
+          let _v = characters(at: index, type: Rapunzel.self)
+          try contentEncoder.encode(_v)
+        case .belle:
+          let _v = characters(at: index, type: BookReader.self)
+          try contentEncoder.encode(_v)
+        case .bookfan:
+          let _v = characters(at: index, type: BookReader.self)
+          try contentEncoder.encode(_v)
+        case .other:
+          let _v = characters(at: index, type: String.self)
+          try contentEncoder.encode(_v)
+        case .unused:
+          let _v = characters(at: index, type: String.self)
+          try contentEncoder.encode(_v)
+        default: break;
+        }
+      }
+    }
+  }
+}
+
+public class MovieT: NativeObject {
+
+  public var mainCharacter: CharacterUnion?
+  public var characters: [CharacterUnion?]
+
+  public init(_ _t: inout Movie) {
+    switch _t.mainCharacterType {
+    case .mulan:
+      var _v = _t.mainCharacter(type: Attacker.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .mulan)
+    case .rapunzel:
+      var _v = _t.mainCharacter(type: Rapunzel_Mutable.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .rapunzel)
+    case .belle:
+      var _v = _t.mainCharacter(type: BookReader_Mutable.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .belle)
+    case .bookfan:
+      var _v = _t.mainCharacter(type: BookReader_Mutable.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .bookfan)
+    case .other:
+      var _v = _t.mainCharacter(type: String.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .other)
+    case .unused:
+      var _v = _t.mainCharacter(type: String.self)
+      mainCharacter = CharacterUnion(_v?.unpack(), type: .unused)
+    default: break
+    }
+    characters = []
+    for index in 0..<_t.charactersCount {
+        switch _t.charactersType(at: index) {
+        case .mulan:
+          var _v = _t.characters(at: index, type: Attacker.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .mulan))
+        case .rapunzel:
+          var _v = _t.characters(at: index, type: Rapunzel_Mutable.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .rapunzel))
+        case .belle:
+          var _v = _t.characters(at: index, type: BookReader_Mutable.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .belle))
+        case .bookfan:
+          var _v = _t.characters(at: index, type: BookReader_Mutable.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .bookfan))
+        case .other:
+          var _v = _t.characters(at: index, type: String.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .other))
+        case .unused:
+          var _v = _t.characters(at: index, type: String.self)
+          characters.append(CharacterUnion(_v?.unpack(), type: .unused))
+        default: break
+        }
+    }
+  }
+
+  public init() {
+    characters = []
+  }
+
+  public func serialize() -> ByteBuffer { return serialize(type: Movie.self) }
+
+}

tests/swift/Tests/Flatbuffers/vector_has_test_generated.swift

@@ -0,0 +1,86 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public struct Swift_Tests_Vectors: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_25_2_10() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  private init(_ t: Table) { _accessor = t }
+  public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+  private enum VTOFFSET: VOffset {
+    case none_ = 4
+    case empty = 6
+    case array = 8
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var hasNone: Bool { let o = _accessor.offset(VTOFFSET.none_.v); return o == 0 ? false : true }
+  public var none_Count: Int32 { let o = _accessor.offset(VTOFFSET.none_.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func none_(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.none_.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
+  public var none_: [UInt64] { return _accessor.getVector(at: VTOFFSET.none_.v) ?? [] }
+  public func withUnsafePointerToNone<T>(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.none_.v, body: body) }
+  public var hasEmpty: Bool { let o = _accessor.offset(VTOFFSET.empty.v); return o == 0 ? false : true }
+  public var emptyCount: Int32 { let o = _accessor.offset(VTOFFSET.empty.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func empty(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.empty.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
+  public var empty: [UInt64] { return _accessor.getVector(at: VTOFFSET.empty.v) ?? [] }
+  public func withUnsafePointerToEmpty<T>(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.empty.v, body: body) }
+  public var hasArray: Bool { let o = _accessor.offset(VTOFFSET.array.v); return o == 0 ? false : true }
+  public var arrayCount: Int32 { let o = _accessor.offset(VTOFFSET.array.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func array(at index: Int32) -> UInt64 { let o = _accessor.offset(VTOFFSET.array.v); return o == 0 ? 0 : _accessor.directRead(of: UInt64.self, offset: _accessor.vector(at: o) + index * 8) }
+  public var array: [UInt64] { return _accessor.getVector(at: VTOFFSET.array.v) ?? [] }
+  public func withUnsafePointerToArray<T>(_ body: (UnsafeRawBufferPointer) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.array.v, body: body) }
+  public static func startVectors(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 3) }
+  public static func addVectorOf(none_: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: none_, at: VTOFFSET.none_.p) }
+  public static func addVectorOf(empty: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: empty, at: VTOFFSET.empty.p) }
+  public static func addVectorOf(array: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: array, at: VTOFFSET.array.p) }
+  public static func endVectors(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createVectors(
+    _ fbb: inout FlatBufferBuilder,
+    none_VectorOffset none_: Offset = Offset(),
+    emptyVectorOffset empty: Offset = Offset(),
+    arrayVectorOffset array: Offset = Offset()
+  ) -> Offset {
+    let __start = Swift_Tests_Vectors.startVectors(&fbb)
+    Swift_Tests_Vectors.addVectorOf(none_: none_, &fbb)
+    Swift_Tests_Vectors.addVectorOf(empty: empty, &fbb)
+    Swift_Tests_Vectors.addVectorOf(array: array, &fbb)
+    return Swift_Tests_Vectors.endVectors(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.none_.p, fieldName: "none_", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
+    try _v.visit(field: VTOFFSET.empty.p, fieldName: "empty", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
+    try _v.visit(field: VTOFFSET.array.p, fieldName: "array", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
+    _v.finish()
+  }
+}
+
+extension Swift_Tests_Vectors: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case none_ = "none"
+    case empty = "empty"
+    case array = "array"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if none_Count > 0 {
+      try container.encodeIfPresent(none_, forKey: .none_)
+    }
+    if emptyCount > 0 {
+      try container.encodeIfPresent(empty, forKey: .empty)
+    }
+    if arrayCount > 0 {
+      try container.encodeIfPresent(array, forKey: .array)
+    }
+  }
+}
+

tests/swift/Tests/Flexbuffers/FlexBuffersJSONTests.swift

@@ -0,0 +1,50 @@
+/*
+ * 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 Common
+import FlexBuffers
+import XCTest
+
+final class FlexBuffersJSONTests: XCTestCase {
+  func testEncodingJSON() throws {
+    let buf: ByteBuffer = createProperBuffer().sizedByteBuffer
+    let reference = try getRoot(buffer: buf)!
+
+    let json = reference.jsonString()
+    // swiftformat:disable all
+    XCTAssertEqual(
+      json,
+      "{\"bar\": [1, 2, 3], \"bar3\": [1, 2, 3], \"bool\": true, \"bools\": [true, false, true, false], \"foo\": 100.0, \"mymap\": {\"foo\": \"Fred\"}, \"vec\": [-100, \"Fred\", 4.0, \"M\", false, 4.0]}"
+    )
+    // swiftformat:enable all
+
+    let data = json.data(using: .utf8)!
+    let decodedData = try JSONSerialization.jsonObject(
+      with: data,
+      options: []) as! [String: Any]
+
+    XCTAssertEqual(decodedData["bar"] as! [Int], [1, 2, 3])
+    XCTAssertEqual(decodedData["bar3"] as! [Int], [1, 2, 3])
+
+    let vec: [Any] = decodedData["vec"] as! [Any]
+    XCTAssertEqual(vec[0] as! Int, -100)
+    XCTAssertEqual(vec[1] as! String, "Fred")
+    XCTAssertEqual(vec[2] as! Double, 4.0)
+    XCTAssertEqual(vec[3] as! String, "M")
+    XCTAssertEqual(vec[4] as! Bool, false)
+    XCTAssertEqual(vec[5] as! Double, 4.0)
+  }
+}

tests/swift/Tests/Flexbuffers/FlexBuffersReaderTests.swift

@@ -0,0 +1,116 @@
+/*
+ * 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 Common
+import FlexBuffers
+import XCTest
+
+final class FlexBuffersReaderTests: XCTestCase {
+
+  func testReadingProperBuffer() throws {
+    let buf: ByteBuffer = createProperBuffer().byteBuffer
+    try validate(buffer: buf)
+  }
+
+  func testReadingSizedBuffer() throws {
+    let buf: ByteBuffer = createSizedBuffer()
+    try validate(buffer: buf)
+  }
+
+  private func validate(buffer buf: ByteBuffer) throws {
+    let reference = try getRoot(buffer: buf)!
+    XCTAssertEqual(reference.type, .map)
+    let map = reference.map!
+    XCTAssertEqual(map.count, 7)
+    let vecRef = map["vec"]!
+    XCTAssertEqual(vecRef.type, .vector)
+    let vec = vecRef.vector!
+    XCTAssertEqual(vec.count, 6)
+    XCTAssertEqual(vec[0]?.type, .int)
+    XCTAssertEqual(vec[0]?.int, -100)
+    XCTAssertEqual(vec[1]?.type, .string)
+    XCTAssertEqual(vec[1]?.cString, "Fred")
+    XCTAssertNil(vec[1]?.int)
+    XCTAssertEqual(vec[2]?.double, 4.0)
+    XCTAssertTrue(vec[3]?.type == .blob)
+
+    let blob = vec[3]!.blob { pointer in
+      Array(pointer)
+    }
+
+    XCTAssertEqual(blob?.count, 1)
+    XCTAssertEqual(blob?[0], 77)
+    XCTAssertEqual(vec[4]?.type, .bool)
+    XCTAssertEqual(vec[4]?.bool, false)
+    XCTAssertEqual(vec[5]?.double, 4.0) // Shared with vec[2]
+
+    let barVec = map["bar"]!.typedVector!
+    XCTAssertEqual(barVec.count, 3)
+    XCTAssertEqual(barVec[2]?.int, 3)
+    XCTAssertEqual(barVec[2]?.asInt(), UInt8(3))
+
+    let fixedVec = map["bar3"]!.fixedTypedVector!
+    XCTAssertEqual(fixedVec.count, 3)
+    XCTAssertEqual(fixedVec[2]?.int, 3)
+    XCTAssertEqual(fixedVec[2]?.asInt(), UInt8(3))
+    XCTAssertEqual(map["bool"]?.bool, true)
+
+    let boolsVector = map["bools"]!.typedVector!
+    XCTAssertEqual(boolsVector.type, .bool)
+    XCTAssertEqual(boolsVector[0]?.bool, true)
+    XCTAssertEqual(boolsVector[1]?.bool, false)
+
+    let bools = [true, false, true, false]
+    boolsVector.withUnsafeRawBufferPointer { buff in
+      for i in 0..<boolsVector.count {
+        XCTAssertEqual(buff.load(fromByteOffset: i, as: Bool.self), bools[i])
+      }
+    }
+    XCTAssertEqual(map["foo"]?.double, 100)
+    XCTAssertNil(map["unknown"])
+    let mymap = map["mymap"]?.map
+
+    // Check if both addresses used are the same for keys and strings
+    XCTAssertEqual(mymap?.keys[0]?.cString, map.keys[4]?.cString)
+    map.keys[4]?.withUnsafeRawPointer { pointer in
+      mymap?.keys[0]?.withUnsafeRawPointer { mymapPointer in
+        XCTAssertEqual(pointer, mymapPointer)
+      }
+    }
+
+    XCTAssertEqual(mymap?.values[0]?.cString, vec[1]?.cString)
+    vec[1]?.withUnsafeRawPointer { pointer in
+      mymap?.values[0]?.withUnsafeRawPointer { mymapPointer in
+        XCTAssertEqual(pointer, mymapPointer)
+      }
+    }
+  }
+
+  private var path: String {
+    #if os(macOS)
+    // Gets the current path of this test file then
+    // strips out the nested directories.
+    let filePath = URL(filePath: #file)
+      .deletingLastPathComponent()
+      .deletingLastPathComponent()
+      .deletingLastPathComponent()
+    return filePath.absoluteString
+    #else
+    return FileManager.default.currentDirectoryPath
+    #endif
+  }
+
+}

tests/swift/Tests/Flexbuffers/FlexBuffersStringTests.swift

@@ -0,0 +1,43 @@
+/*
+ * 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 Common
+import FlexBuffers
+import XCTest
+
+final class FlexBuffersStringTests: XCTestCase {
+
+  func testEncodingUnicodeString() {
+    let text = "プ画をみて✋"
+
+    let bytes = text.data(using: .unicode, allowLossyConversion: true)
+    var flx = FlexBuffersWriter()
+    flx.map { writer in
+      writer.add(blob: bytes!, key: "text", length: bytes!.count)
+    }
+    flx.finish()
+    let byteBuffer = flx.sizedByteBuffer
+
+    let reference = try! getRoot(buffer: byteBuffer)
+    let root = reference?.map?["text"]
+    let builtString = root?.blob {
+      let data = Data(bytes: $0.baseAddress!, count: Int($0.count))
+      return String(data: data, encoding: .unicode)
+    }
+
+    XCTAssertEqual(builtString, text)
+  }
+}

tests/swift/Tests/Flexbuffers/FlexBuffersWriterTests.swift

@@ -0,0 +1,236 @@
+/*
+ * 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 Common
+import FlexBuffers
+import XCTest
+
+final class FlexBuffersWriterTests: XCTestCase {
+  func testDeallocation() {
+    let buf: ByteBuffer = {
+      var fbx = FlexBuffersWriter()
+      fbx.add(string: "Hello")
+      fbx.finish()
+      return fbx.sizedByteBuffer
+    }()
+
+    buf.withUnsafeBytes {
+      XCTAssertEqual(
+        Array($0),
+        [5, 72, 101, 108, 108, 111, 0, 6, 20, 1])
+    }
+  }
+
+  func testAddingVectorOfScalars() {
+    var fbx = FlexBuffersWriter()
+    fbx.vector {
+      let arr: [Int32] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 20]
+      $0.create(vector: arr)
+    }
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        [10, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7, 0, 0, 0, 8, 0, 0, 0, 9, 0, 0, 0, 20, 0, 0, 0, 1, 41, 46, 2, 40, 1])
+      // swiftformat:enable all
+    }
+  }
+
+  func testAddingVectorOfUnsignedScalars() {
+    var fbx = FlexBuffersWriter()
+    fbx.vector {
+      let arr: [UInt] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 20]
+      $0.create(vector: arr)
+    }
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        [10, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 1, 81, 51, 2, 40, 1])
+      // swiftformat:enable all
+    }
+  }
+
+  func testAddingVectorOfBools() {
+    var fbx = FlexBuffersWriter()
+    fbx.vector {
+      let arr: [Bool] = [true, false, true, false]
+      $0.create(vector: arr)
+    }
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        [4, 1, 0, 1, 0, 1, 5, 144, 2, 40, 1])
+      // swiftformat:enable all
+    }
+  }
+
+  func testSortingWithinMap() {
+    var fbx = FlexBuffersWriter()
+    fbx.map {
+      $0.add(bool: false, key: "bool2")
+      $0.add(bool: true, key: "bool1")
+    }
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        [98, 111, 111, 108, 50, 0, 98, 111, 111, 108, 49, 0, 2, 7, 14, 2, 1, 2, 1, 0, 104, 104, 4, 36, 1]
+      )
+      // swiftformat:enable all
+    }
+  }
+
+  func testSharingKeyWithinMap() {
+    var fbx = FlexBuffersWriter(initialSize: 1000, flags: .shareKeysAndStrings)
+    fbx.map {
+      $0.add(string: "welcome", key: "welcome")
+      $0.add(string: "welcome", key: "welcome")
+      $0.add(string: "welcome", key: "welcome")
+    }
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        [119, 101, 108, 99, 111, 109, 101, 0, 7, 119, 101, 108, 99, 111, 109, 101, 0, 3, 18, 19, 20, 3, 1, 3, 15, 16, 17, 20, 20, 20, 6, 36, 1]
+      )
+      // swiftformat:enable all
+    }
+  }
+
+  func testNestingVectorInMap() {
+    let buf: ByteBuffer = createSizedBuffer()
+
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        flexbufferGolden
+      )
+      // swiftformat:enable all
+    }
+  }
+
+  func testAddingNil() {
+    var fbx = FlexBuffersWriter(
+      initialSize: 8,
+      flags: .shareKeysAndStrings)
+
+    fbx.map { map in
+      map.addNil(key: "v")
+    }
+
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        [118, 0, 1, 3, 1, 1, 1, 0, 0, 2, 36, 1]
+      )
+      // swiftformat:enable all
+    }
+  }
+
+  func testAddingManually() {
+    var fbx = FlexBuffersWriter(
+      initialSize: 8,
+      flags: .shareKeysAndStrings)
+
+    let outerMap = fbx.startMap()
+
+    let vector = fbx.startVector(key: "vec")
+    fbx.add(int64: -100)
+    fbx.add(string: "Fred")
+    fbx.indirect(float32: 4.0)
+    let lv = fbx.lastValue()
+    let blob: [UInt8] = [77]
+    fbx.add(blob: blob, length: blob.count)
+    fbx.add(bool: false)
+    fbx.reuse(value: lv!)
+    fbx.endVector(start: vector)
+
+    let ints: [Int32] = [1, 2, 3]
+    fbx.create(vector: ints, key: "bar")
+    fbx.createFixed(vector: ints, key: "bar3")
+    let bools = [true, false, true, false]
+    fbx.create(vector: bools, key: "bools")
+    fbx.add(bool: true, key: "bool")
+    fbx.add(double: 100, key: "foo")
+
+    let innerMap = fbx.startMap(key: "mymap")
+    fbx.add(string: "Fred", key: "foo")
+    fbx.endMap(start: innerMap)
+
+    fbx.endMap(start: outerMap)
+
+
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        flexbufferGolden
+      )
+      // swiftformat:enable all
+    }
+  }
+
+  func testEncodingAllTypes() {
+    var fbx = FlexBuffersWriter()
+    fbx.vector {
+      $0.indirect(int64: 9)
+      $0.indirect(uint64: 9)
+      $0.indirect(float32: 3)
+      $0.indirect(double: 3)
+
+      $0.addNil()
+      $0.add(bool: true)
+      $0.add(int64: 9)
+      $0.add(int64: -9)
+      $0.add(uint64: 9)
+      $0.add(double: 2.4)
+      $0.add(float32: 2.4)
+      $0.add(double: -2.4)
+      $0.add(float32: -2.4)
+    }
+    fbx.finish()
+    let buf: ByteBuffer = fbx.sizedByteBuffer
+
+    buf.withUnsafeBytes {
+      // swiftformat:disable all
+      XCTAssertEqual(
+        Array($0),
+        allTypesGolden)
+      // swiftformat:enable all
+    }
+  }
+}

tests/swift/Tests/Flexbuffers/Mocks.swift

@@ -0,0 +1,61 @@
+/*
+ * 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 FlexBuffers
+
+// swiftformat:disable all
+let flexbufferGolden: [UInt8] = [118, 101, 99, 0, 4, 70, 114, 101, 100, 0, 0, 0, 0, 0, 128, 64, 1, 77, 6, 156, 15, 9, 5, 0, 12, 4, 20, 34, 100, 104, 34, 98, 97, 114, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 98, 97, 114, 51, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 98, 111, 111, 108, 115, 0, 4, 1, 0, 1, 0, 98, 111, 111, 108, 0, 102, 111, 111, 0, 109, 121, 109, 97, 112, 0, 1, 11, 1, 1, 1, 98, 20, 7, 75, 55, 25, 37, 22, 19, 112, 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 88, 0, 0, 0, 72, 0, 0, 0, 1, 0, 0, 0, 61, 0, 0, 0, 0, 0, 200, 66, 45, 0, 0, 0, 133, 0, 0, 0, 46, 78, 106, 144, 14, 36, 40, 35, 38, 1]
+
+let allTypesGolden: [UInt8] = [9, 9, 0, 0, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 247, 255, 255, 255, 255, 255, 255, 255, 9, 0, 0, 0, 0, 0, 0, 0, 51, 51, 51, 51, 51, 51, 3, 64, 0, 0, 0, 64, 51, 51, 3, 64, 51, 51, 51, 51, 51, 51, 3, 192, 0, 0, 0, 64, 51, 51, 3, 192, 24, 28, 34, 34, 3, 107, 7, 7, 11, 15, 15, 15, 15, 117, 43, 1]
+// swiftformat:enable all
+
+@inline(__always)
+func createSizedBuffer() -> ByteBuffer {
+  createProperBuffer().sizedByteBuffer
+}
+
+@inline(__always)
+func createProperBuffer() -> FlexBuffersWriter {
+  var fbx = FlexBuffersWriter(
+    initialSize: 8,
+    flags: .shareKeysAndStrings)
+
+  fbx.map { map in
+    map.vector(key: "vec") { v in
+      v.add(int64: -100)
+      v.add(string: "Fred")
+      v.indirect(float32: 4.0)
+      let lv = v.lastValue()
+      let blob: [UInt8] = [77]
+      v.add(blob: blob, length: blob.count)
+      v.add(bool: false)
+      v.reuse(value: lv!)
+    }
+    let ints: [Int32] = [1, 2, 3]
+    map.create(vector: ints, key: "bar")
+    map.createFixed(vector: ints, key: "bar3")
+    let bools = [true, false, true, false]
+    map.create(vector: bools, key: "bools")
+    map.add(bool: true, key: "bool")
+    map.add(double: 100, key: "foo")
+    map.map(key: "mymap") { m in
+      m.add(string: "Fred", key: "foo")
+    }
+  }
+
+  fbx.finish()
+  return fbx
+}