[Swift] Object API support (#5826)

* Adds Object-api support to swift

* Fixed indentation issues

* Removed indentation within namespaces

docs/source/Support.md

@@ -22,7 +22,7 @@ Feature                        | C++    | Java   | C#     | Go     | Python | JS
 ------------------------------ | ------ | ------ | ------ | ------ | ------ | --------- | --------- | ------  | --- | ------- | ------- | ------- | ------
 Codegen for all basic features | Yes    | Yes    | Yes    | Yes    | Yes    | Yes       | Yes       | Yes     | WiP | Yes     | Yes     | Yes     | Yes
 JSON parsing                   | Yes    | No     | No     | No     | No     | No        | No        | Yes     | No  | No      | Yes     | No      | No
-Simple mutation                | Yes    | Yes    | Yes    | Yes    | No     | No        | No        | No      | No  | No      | No      | No      | No
+Simple mutation                | Yes    | Yes    | Yes    | Yes    | No     | No        | No        | No      | No  | No      | No      | No      | Yes
 Reflection                     | Yes    | No     | No     | No     | No     | No        | No        | Basic   | No  | No      | No      | No      | No
 Buffer verifier                | Yes    | No     | No     | No     | No     | No        | No        | Yes     | No  | No      | No      | No      | No
 Testing: basic                 | Yes    | Yes    | Yes    | Yes    | Yes    | Yes       | Yes       | Yes     | ?   | Yes     | Yes     | Yes     | Yes

include/flatbuffers/code_generators.h

@@ -75,6 +75,10 @@ class CodeWriter {
   void DecrementIdentLevel() {
     if (cur_ident_lvl_) cur_ident_lvl_--;
   }
+    
+  void SetPadding(const std::string &padding) {
+    pad_ = padding;
+  }
 
  private:
   std::map<std::string, std::string> value_map_;

swift/Sources/FlatBuffers/ByteBuffer.swift

@@ -131,6 +131,16 @@ public struct ByteBuffer {
             push(value: s, len: MemoryLayout.size(ofValue: s))
         }
     }
+    
+    ///Adds an array of type Bool to the buffer memory
+    /// - Parameter elements: An array of Bool
+    @usableFromInline mutating func push(elements: [Bool]) {
+        let size = elements.count * MemoryLayout<Bool>.size
+        ensureSpace(size: UInt32(size))
+        elements.lazy.reversed().forEach { (s) in
+            push(value: s ? 1 : 0, len: MemoryLayout.size(ofValue: s))
+        }
+    }
 
     /// A custom type of structs that are padded according to the flatbuffer padding,
     /// - Parameters:
@@ -174,8 +184,6 @@ public struct ByteBuffer {
     ///   - len: Size of string
     @usableFromInline mutating internal func push(bytes: UnsafeBufferPointer<String.UTF8View.Element>, len: Int) -> Bool {
         memcpy(_storage.memory.advanced(by: writerIndex - len), UnsafeRawPointer(bytes.baseAddress!), len)
-//        _memory.advanced(by: writerIndex - len).copyMemory(from:
-//            UnsafeRawPointer(bytes.baseAddress!), byteCount: len)
         _writerSize += len
         return true
     }

swift/Sources/FlatBuffers/FlatBufferBuilder.swift

@@ -53,7 +53,7 @@ public struct FlatBufferBuilder {
     /// Returns A sized Buffer from the readable bytes
     public var sizedBuffer: ByteBuffer {
         assert(finished, "Data shouldn't be called before finish()")
-        return ByteBuffer(memory: _bb.memory.advanced(by: _bb.reader), count: _bb.reader)
+        return ByteBuffer(memory: _bb.memory.advanced(by: _bb.reader), count: Int(_bb.size))
     }
     
     // MARK: - Init
@@ -276,6 +276,24 @@ public struct FlatBufferBuilder {
         return push(element: Int32(len))
     }
     
+    /// Creates a vector of type Bool in the buffer
+    /// - Parameter elements: elements to be written into the buffer
+    /// - returns: Offset of the vector
+    mutating public func createVector(_ elements: [Bool]) -> Offset<UOffset> {
+        return createVector(elements, size: elements.count)
+    }
+    
+    ///  Creates a vector of type Bool in the buffer
+    /// - Parameter elements: Elements to be written into the buffer
+    /// - Parameter size: Count of elements
+    /// - returns: Offset of the vector
+    mutating public func createVector(_ elements: [Bool], size: Int) -> Offset<UOffset> {
+        let size = size
+        startVector(size, elementSize: MemoryLayout<Bool>.size)
+        _bb.push(elements: elements)
+        return Offset(offset: endVector(len: size))
+    }
+    
     /// Creates a vector of type Scalar in the buffer
     /// - Parameter elements: elements to be written into the buffer
     /// - returns: Offset of the vector

swift/Sources/FlatBuffers/FlatBufferObject.swift

@@ -6,6 +6,14 @@ public protocol FlatBufferObject {
     init(_ bb: ByteBuffer, o: Int32)
 }
 
+public protocol NativeTable {}
+
+public protocol ObjectAPI {
+    associatedtype T
+    static func pack(_ builder: inout FlatBufferBuilder, obj: inout T) -> Offset<UOffset>
+    mutating func unpack() -> T
+}
+
 /// Readable is structures all the Flatbuffers structs
 ///
 /// Readable is a procotol that each Flatbuffer struct should confirm to since

tests/FlatBuffers.GRPC.Swift/Sources/Model/greeter_generated.swift

@@ -4,77 +4,77 @@ import FlatBuffers
 
 public struct HelloReply: FlatBufferObject {
 
-	static func validateVersion() { FlatBuffersVersion_1_12_0() }
-	public var __buffer: ByteBuffer! { return _accessor.bb }
-
-	private var _accessor: Table
-	public static func getRootAsHelloReply(bb: ByteBuffer) -> HelloReply { return HelloReply(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
-
-	private init(_ t: Table) { _accessor = t }
-	public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
-
-	public var message: String? { let o = _accessor.offset(4); return o == 0 ? nil : _accessor.string(at: o) }
-	public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: 4) }
-	public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
-	public static func add(message: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: 0)  }
-	public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-	public static func createHelloReply(_ fbb: inout FlatBufferBuilder,
-		offsetOfMessage message: Offset<String> = Offset()) -> Offset<UOffset> {
-		let __start = HelloReply.startHelloReply(&fbb)
-		HelloReply.add(message: message, &fbb)
-		return HelloReply.endHelloReply(&fbb, start: __start)
-	}
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func getRootAsHelloReply(bb: ByteBuffer) -> HelloReply { return HelloReply(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public var message: String? { let o = _accessor.offset(4); return o == 0 ? nil : _accessor.string(at: o) }
+    public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: 4) }
+    public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+    public static func add(message: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: 0)  }
+    public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createHelloReply(_ fbb: inout FlatBufferBuilder,
+    offsetOfMessage message: Offset<String> = Offset()) -> Offset<UOffset> {
+        let __start = HelloReply.startHelloReply(&fbb)
+        HelloReply.add(message: message, &fbb)
+        return HelloReply.endHelloReply(&fbb, start: __start)
+    }
 }
 
 public struct HelloRequest: FlatBufferObject {
 
-	static func validateVersion() { FlatBuffersVersion_1_12_0() }
-	public var __buffer: ByteBuffer! { return _accessor.bb }
-
-	private var _accessor: Table
-	public static func getRootAsHelloRequest(bb: ByteBuffer) -> HelloRequest { return HelloRequest(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
-
-	private init(_ t: Table) { _accessor = t }
-	public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
-
-	public var name: String? { let o = _accessor.offset(4); return o == 0 ? nil : _accessor.string(at: o) }
-	public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: 4) }
-	public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
-	public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: 0)  }
-	public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-	public static func createHelloRequest(_ fbb: inout FlatBufferBuilder,
-		offsetOfName name: Offset<String> = Offset()) -> Offset<UOffset> {
-		let __start = HelloRequest.startHelloRequest(&fbb)
-		HelloRequest.add(name: name, &fbb)
-		return HelloRequest.endHelloRequest(&fbb, start: __start)
-	}
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func getRootAsHelloRequest(bb: ByteBuffer) -> HelloRequest { return HelloRequest(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public var name: String? { let o = _accessor.offset(4); return o == 0 ? nil : _accessor.string(at: o) }
+    public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: 4) }
+    public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
+    public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: 0)  }
+    public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createHelloRequest(_ fbb: inout FlatBufferBuilder,
+    offsetOfName name: Offset<String> = Offset()) -> Offset<UOffset> {
+        let __start = HelloRequest.startHelloRequest(&fbb)
+        HelloRequest.add(name: name, &fbb)
+        return HelloRequest.endHelloRequest(&fbb, start: __start)
+    }
 }
 
 public struct ManyHellosRequest: FlatBufferObject {
 
-	static func validateVersion() { FlatBuffersVersion_1_12_0() }
-	public var __buffer: ByteBuffer! { return _accessor.bb }
-
-	private var _accessor: Table
-	public static func getRootAsManyHellosRequest(bb: ByteBuffer) -> ManyHellosRequest { return ManyHellosRequest(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
-
-	private init(_ t: Table) { _accessor = t }
-	public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
-
-	public var name: String? { let o = _accessor.offset(4); return o == 0 ? nil : _accessor.string(at: o) }
-	public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: 4) }
-	public var numGreetings: Int32 { let o = _accessor.offset(6); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
-	public static func startManyHellosRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }
-	public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: 0)  }
-	public static func add(numGreetings: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: numGreetings, def: 0, at: 1) }
-	public static func endManyHellosRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-	public static func createManyHellosRequest(_ fbb: inout FlatBufferBuilder,
-		offsetOfName name: Offset<String> = Offset(),
-		numGreetings: Int32 = 0) -> Offset<UOffset> {
-		let __start = ManyHellosRequest.startManyHellosRequest(&fbb)
-		ManyHellosRequest.add(name: name, &fbb)
-		ManyHellosRequest.add(numGreetings: numGreetings, &fbb)
-		return ManyHellosRequest.endManyHellosRequest(&fbb, start: __start)
-	}
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func getRootAsManyHellosRequest(bb: ByteBuffer) -> ManyHellosRequest { return ManyHellosRequest(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public var name: String? { let o = _accessor.offset(4); return o == 0 ? nil : _accessor.string(at: o) }
+    public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: 4) }
+    public var numGreetings: Int32 { let o = _accessor.offset(6); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    public static func startManyHellosRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }
+    public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: 0)  }
+    public static func add(numGreetings: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: numGreetings, def: 0, at: 1) }
+    public static func endManyHellosRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createManyHellosRequest(_ fbb: inout FlatBufferBuilder,
+    offsetOfName name: Offset<String> = Offset(),
+    numGreetings: Int32 = 0) -> Offset<UOffset> {
+        let __start = ManyHellosRequest.startManyHellosRequest(&fbb)
+        ManyHellosRequest.add(name: name, &fbb)
+        ManyHellosRequest.add(numGreetings: numGreetings, &fbb)
+        return ManyHellosRequest.endManyHellosRequest(&fbb, start: __start)
+    }
 }
 

tests/FlatBuffers.Test.Swift/Package.swift

@@ -13,6 +13,7 @@ let package = Package(
         .package(path: "../../swift/")
     ],
     targets: [
+        .target(name: "SwiftFlatBuffers"),
         .testTarget(
             name: "FlatBuffers.Test.SwiftTests",
             dependencies: ["FlatBuffers"]),

tests/FlatBuffers.Test.Swift/Sources/SwiftFlatBuffers/main.swift

+import Foundation
+print("Flatbuffers")

tests/FlatBuffers.Test.Swift/SwiftTest.sh

@@ -2,9 +2,9 @@ swift_dir=`pwd`
 cd ..
 test_dir=`pwd`
 
-${test_dir}/../flatc --swift --gen-mutable -I ${test_dir}/include_test ${test_dir}/monster_test.fbs ${test_dir}/union_vector/union_vector.fbs
+${test_dir}/../flatc --swift --gen-mutable --gen-object-api -I ${test_dir}/include_test ${test_dir}/monster_test.fbs ${test_dir}/union_vector/union_vector.fbs
 cd ${test_dir}
 mv *_generated.swift ${swift_dir}/Tests/FlatBuffers.Test.SwiftTests
 cd ${swift_dir}
 swift build --build-tests
-swift test
\ No newline at end of file
+swift test

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift

@@ -13,7 +13,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         let _data = ByteBuffer(data: data)
         readMonster(fb: _data)
     }
-
+    
     func testReadFromOtherLangagues() {
         let path = FileManager.default.currentDirectoryPath
         let url = URL(fileURLWithPath: path, isDirectory: true).appendingPathComponent("monsterdata_test").appendingPathExtension("mon")
@@ -29,21 +29,33 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         mutateMonster(fb: bytes.buffer)
         readMonster(fb: bytes.buffer)
     }
-
+    
     func testCreateMonsterResizedBuffer() {
         let bytes = createMonster(withPrefix: false)
         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])
-        readMonster(fb: ByteBuffer(data: bytes.data))
+        readMonster(fb: bytes.sizedBuffer)
     }
-
+    
     func testCreateMonsterPrefixed() {
         let bytes = createMonster(withPrefix: true)
         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])
-
+        
         let newBuf = FlatBuffersUtils.removeSizePrefix(bb: bytes.buffer)
         readMonster(fb: newBuf)
     }
-
+    
+    func readMonster(fb: ByteBuffer) {
+        var monster = Monster1.getRootAsMonster(bb: fb)
+        readFlatbufferMonster(monster: &monster)
+        var unpacked: MyGame.Example.MonsterT? = monster.unpack()
+        readObjectApi(monster: unpacked!)
+        var builder = FlatBufferBuilder()
+        let root = Monster1.pack(&builder, obj: &unpacked)
+        builder.finish(offset: root)
+        var newMonster = Monster1.getRootAsMonster(bb: builder.sizedBuffer)
+        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")]
@@ -57,15 +69,15 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         let start3 = Monster1.startMonster(&fbb)
         Monster1.add(name: names[2], &fbb)
         offsets.append(Monster1.endMonster(&fbb, start: start3))
-
+        
         let sortedArray = Monster1.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 = Monster1.startMonster(&fbb)
         Monster1.add(name: fred, &fbb)
@@ -73,9 +85,9 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         let test4 = fbb.createVector(structs: [MyGame.Example.createTest(a: 30, b: 40),
                                                MyGame.Example.createTest(a: 10, b: 20)],
                                      type: Test1.self)
-
+        
         let stringTestVector = fbb.createVector(ofOffsets: [test1, test2])
-
+        
         let mStart = Monster1.startMonster(&fbb)
         let posOffset = fbb.create(struct: MyGame.Example.createVec3(x: 1, y: 2, z: 3, test1: 3, test2: .green, test3a: 5, test3b: 6), type: Vec3.self)
         Monster1.add(pos: posOffset, &fbb)
@@ -92,37 +104,37 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         Monster1.finish(&fbb, end: end, prefix: prefix)
         return fbb
     }
-
+    
     func mutateMonster(fb: ByteBuffer) {
         let monster = Monster1.getRootAsMonster(bb: 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.pos
         XCTAssertEqual(vec?.x, 1)
         XCTAssertTrue(vec?.mutate(x: 55.0) ?? false)
@@ -133,9 +145,8 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         XCTAssertEqual(vec?.x, 1)
         XCTAssertTrue(vec?.mutate(test1: 3) ?? false)
     }
-
-    func readMonster(fb: ByteBuffer) {
-        let monster = Monster1.getRootAsMonster(bb: fb)
+        
+    func readFlatbufferMonster(monster: inout MyGame.Example.Monster) {
         XCTAssertEqual(monster.hp, 80)
         XCTAssertEqual(monster.mana, 150)
         XCTAssertEqual(monster.name, "MyMonster")
@@ -177,14 +188,56 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
         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)
+    }
 }

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift

@@ -91,7 +91,7 @@ final class FlatBuffersUnionTests: XCTestCase {
         let end = Movie.createMovie(&fb, vectorOfCharactersType: types, vectorOfCharacters: characterVector)
         Movie.finish(&fb, end: end)
         
-        let movie = Movie.getRootAsMovie(bb: fb.buffer)
+        var movie = Movie.getRootAsMovie(bb: fb.buffer)
         XCTAssertEqual(movie.charactersTypeCount, Int32(characterType.count))
         XCTAssertEqual(movie.charactersCount, Int32(characters.count))
         
@@ -102,6 +102,19 @@ final class FlatBuffersUnionTests: XCTestCase {
         XCTAssertEqual(movie.characters(at: 0, type: BookReader.self)?.booksRead, 7)
         XCTAssertEqual(movie.characters(at: 1, type: Attacker.self)?.swordAttackDamage, swordDmg)
         XCTAssertEqual(movie.characters(at: 2, type: BookReader.self)?.booksRead, 2)
+        
+        var objc: MovieT? = movie.unpack()
+        XCTAssertEqual(movie.charactersTypeCount, Int32(objc?.characters.count ?? 0))
+        XCTAssertEqual(movie.characters(at: 0, type: BookReader.self)?.booksRead, (objc?.characters[0]?.value as? BookReaderT)?.booksRead)
+        fb.clear()
+        let newMovie = Movie.pack(&fb, obj: &objc)
+        fb.finish(offset: newMovie)
+        
+        let packedMovie = Movie.getRootAsMovie(bb: fb.buffer)
+
+        XCTAssertEqual(packedMovie.characters(at: 0, type: BookReader.self)?.booksRead, movie.characters(at: 0, type: BookReader.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.self)?.booksRead, movie.characters(at: 2, type: BookReader.self)?.booksRead)
     }
 }
 

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift

@@ -3,124 +3,292 @@
 import FlatBuffers
 
 public enum Character: UInt8, Enum { 
-	public typealias T = UInt8
-	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 }
+    public typealias T = UInt8
+    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 }
 }
 
+struct CharacterUnion {
+    var type: Character
+    var value: NativeTable?
+    init(_ v: NativeTable?, type: Character) {
+        self.type = type
+        self.value = v
+    }
+    func pack(builder: inout FlatBufferBuilder) -> Offset<UOffset> {
+        switch type {
+        case .mulan:
+            var __obj = value as? AttackerT
+            return Attacker.pack(&builder, obj: &__obj)
+        case .rapunzel:
+            var __obj = value as? RapunzelT
+            return Rapunzel.pack(&builder, obj: &__obj)
+        case .belle:
+            var __obj = value as? BookReaderT
+            return BookReader.pack(&builder, obj: &__obj)
+        case .bookfan:
+            var __obj = value as? BookReaderT
+            return BookReader.pack(&builder, obj: &__obj)
+        default: return Offset()
+        }
+    }
+}
 public struct Rapunzel: Readable {
 
-	static func validateVersion() { FlatBuffersVersion_1_12_0() }
-	public var __buffer: ByteBuffer! { return _accessor.bb }
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 4
+    public static var alignment = 4
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
 
-	private var _accessor: Struct
-	public static var size = 4
-	public static var alignment = 4	
-	public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+    public var hairLength: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+    public func mutate(hairLength: Int32) -> Bool { return _accessor.mutate(hairLength, index: 0) }
+    
 
-	public var hairLength: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
-	public func mutate(hairLength: Int32) -> Bool { return _accessor.mutate(hairLength, index: 0) }
+    public mutating func unpack() -> RapunzelT {
+        return RapunzelT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout RapunzelT?) -> Offset<UOffset> {
+        guard let obj = obj else { return Offset<UOffset>() }
+
+        return builder.create(struct: createRapunzel(hairLength: obj.hairLength), type: Rapunzel.self)
+    }
 }
 
+public class RapunzelT: NativeTable {
+
+    var hairLength: Int32
+
+    init(_ _t: inout Rapunzel) {
+        hairLength = _t.hairLength
+    }
+
+    init() {
+        hairLength = 0
+    }
+
+}
 public struct BookReader: Readable {
 
-	static func validateVersion() { FlatBuffersVersion_1_12_0() }
-	public var __buffer: ByteBuffer! { return _accessor.bb }
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Struct
+
+    public static var size = 4
+    public static var alignment = 4
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
 
-	private var _accessor: Struct
-	public static var size = 4
-	public static var alignment = 4	
-	public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
+    public var booksRead: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
+    public func mutate(booksRead: Int32) -> Bool { return _accessor.mutate(booksRead, index: 0) }
+    
 
-	public var booksRead: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
-	public func mutate(booksRead: Int32) -> Bool { return _accessor.mutate(booksRead, index: 0) }
+    public mutating func unpack() -> BookReaderT {
+        return BookReaderT(&self)
+    }
+    public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReaderT?) -> Offset<UOffset> {
+        guard let obj = obj else { return Offset<UOffset>() }
+
+        return builder.create(struct: createBookReader(booksRead: obj.booksRead), type: BookReader.self)
+    }
 }
 
+public class BookReaderT: NativeTable {
+
+    var booksRead: Int32
+
+    init(_ _t: inout BookReader) {
+        booksRead = _t.booksRead
+    }
+
+    init() {
+        booksRead = 0
+    }
+
+}
 public func createRapunzel(hairLength: Int32) -> UnsafeMutableRawPointer {
-	let memory = UnsafeMutableRawPointer.allocate(byteCount: Rapunzel.size, alignment: Rapunzel.alignment)
-	memory.initializeMemory(as: UInt8.self, repeating: 0, count: Rapunzel.size)
-	memory.storeBytes(of: hairLength, toByteOffset: 0, as: Int32.self)
-	return memory
+    let memory = UnsafeMutableRawPointer.allocate(byteCount: Rapunzel.size, alignment: Rapunzel.alignment)
+    memory.initializeMemory(as: UInt8.self, repeating: 0, count: Rapunzel.size)
+    memory.storeBytes(of: hairLength, toByteOffset: 0, as: Int32.self)
+    return memory
 }
 
 public func createBookReader(booksRead: Int32) -> UnsafeMutableRawPointer {
-	let memory = UnsafeMutableRawPointer.allocate(byteCount: BookReader.size, alignment: BookReader.alignment)
-	memory.initializeMemory(as: UInt8.self, repeating: 0, count: BookReader.size)
-	memory.storeBytes(of: booksRead, toByteOffset: 0, as: Int32.self)
-	return memory
+    let memory = UnsafeMutableRawPointer.allocate(byteCount: BookReader.size, alignment: BookReader.alignment)
+    memory.initializeMemory(as: UInt8.self, repeating: 0, count: BookReader.size)
+    memory.storeBytes(of: booksRead, toByteOffset: 0, as: Int32.self)
+    return memory
 }
 
 public struct Attacker: FlatBufferObject {
 
-	static func validateVersion() { FlatBuffersVersion_1_12_0() }
-	public var __buffer: ByteBuffer! { return _accessor.bb }
-
-	private var _accessor: Table
-	public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
-	public static func getRootAsAttacker(bb: ByteBuffer) -> Attacker { return Attacker(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
-
-	private init(_ t: Table) { _accessor = t }
-	public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
-
-	public var swordAttackDamage: Int32 { let o = _accessor.offset(4); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
-	public func mutate(swordAttackDamage: Int32) -> Bool {let o = _accessor.offset(4);  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: 0) }
-	public static func endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-	public static func createAttacker(_ fbb: inout FlatBufferBuilder,
-		swordAttackDamage: Int32 = 0) -> Offset<UOffset> {
-		let __start = Attacker.startAttacker(&fbb)
-		Attacker.add(swordAttackDamage: swordAttackDamage, &fbb)
-		return Attacker.endAttacker(&fbb, start: __start)
-	}
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
+    public static func getRootAsAttacker(bb: ByteBuffer) -> Attacker { return Attacker(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public var swordAttackDamage: Int32 { let o = _accessor.offset(4); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    public func mutate(swordAttackDamage: Int32) -> Bool {let o = _accessor.offset(4);  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: 0) }
+    public static func endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createAttacker(_ fbb: inout FlatBufferBuilder,
+    swordAttackDamage: Int32 = 0) -> Offset<UOffset> {
+        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<UOffset> {
+        guard let obj = obj else { return Offset<UOffset>() }
+
+        let __root = Attacker.startAttacker(&builder)
+        Attacker.add(swordAttackDamage: obj.swordAttackDamage, &builder)
+        return Attacker.endAttacker(&builder, start: __root)
+    }
 }
 
+public class AttackerT: NativeTable {
+
+    var swordAttackDamage: Int32
+
+    init(_ _t: inout Attacker) {
+        swordAttackDamage = _t.swordAttackDamage
+    }
+
+    init() {
+        swordAttackDamage = 0
+    }
+
+}
 public struct Movie: FlatBufferObject {
 
-	static func validateVersion() { FlatBuffersVersion_1_12_0() }
-	public var __buffer: ByteBuffer! { return _accessor.bb }
-
-	private var _accessor: Table
-	public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
-	public static func getRootAsMovie(bb: ByteBuffer) -> Movie { return Movie(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
-
-	private init(_ t: Table) { _accessor = t }
-	public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
-
-	public var mainCharacterType: Character { let o = _accessor.offset(4); return o == 0 ? .none : Character(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none }
-	public func mainCharacter<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(6); return o == 0 ? nil : _accessor.union(o) }
-	public var charactersTypeCount: Int32 { let o = _accessor.offset(8); return o == 0 ? 0 : _accessor.vector(count: o) }
-	public func charactersType(at index: Int32) -> Character? { let o = _accessor.offset(8); return o == 0 ? Character.none : Character(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
-	public var charactersCount: Int32 { let o = _accessor.offset(10); return o == 0 ? 0 : _accessor.vector(count: o) }
-	public func characters<T: FlatBufferObject>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(10); 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: 0) }
-	public static func add(mainCharacter: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: 1)  }
-	public static func addVectorOf(charactersType: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: 2)  }
-	public static func addVectorOf(characters: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: 3)  }
-	public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-	public static func createMovie(_ fbb: inout FlatBufferBuilder,
-		mainCharacterType: Character = .none,
-		offsetOfMainCharacter mainCharacter: Offset<UOffset> = Offset(),
-		vectorOfCharactersType charactersType: Offset<UOffset> = Offset(),
-		vectorOfCharacters characters: Offset<UOffset> = Offset()) -> Offset<UOffset> {
-		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)
-	}
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset<UOffset>, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
+    public static func getRootAsMovie(bb: ByteBuffer) -> Movie { return Movie(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    public var mainCharacterType: Character { let o = _accessor.offset(4); return o == 0 ? .none : Character(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none }
+    public func mainCharacter<T: FlatBufferObject>(type: T.Type) -> T? { let o = _accessor.offset(6); return o == 0 ? nil : _accessor.union(o) }
+    public var charactersTypeCount: Int32 { let o = _accessor.offset(8); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func charactersType(at index: Int32) -> Character? { let o = _accessor.offset(8); return o == 0 ? Character.none : Character(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
+    public var charactersCount: Int32 { let o = _accessor.offset(10); return o == 0 ? 0 : _accessor.vector(count: o) }
+    public func characters<T: FlatBufferObject>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(10); 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: 0) }
+    public static func add(mainCharacter: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: 1)  }
+    public static func addVectorOf(charactersType: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: 2)  }
+    public static func addVectorOf(characters: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: 3)  }
+    public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createMovie(_ fbb: inout FlatBufferBuilder,
+    mainCharacterType: Character = .none,
+    offsetOfMainCharacter mainCharacter: Offset<UOffset> = Offset(),
+    vectorOfCharactersType charactersType: Offset<UOffset> = Offset(),
+    vectorOfCharacters characters: Offset<UOffset> = Offset()) -> Offset<UOffset> {
+        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<UOffset> {
+        guard let obj = obj else { return Offset<UOffset>() }
+
+        let __mainCharacter = obj.mainCharacter?.pack(builder: &builder) ?? Offset()
+        var __characters__: [Offset<UOffset>] = []
+        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 class MovieT: NativeTable {
+
+    var mainCharacter: CharacterUnion?
+    var characters: [CharacterUnion?]
+
+    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.self)
+            mainCharacter = CharacterUnion(_v?.unpack(), type: .rapunzel)
+        case .belle:
+            var _v = _t.mainCharacter(type: BookReader.self)
+            mainCharacter = CharacterUnion(_v?.unpack(), type: .belle)
+        case .bookfan:
+            var _v = _t.mainCharacter(type: BookReader.self)
+            mainCharacter = CharacterUnion(_v?.unpack(), type: .bookfan)
+        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.self)
+                characters.append(CharacterUnion(_v?.unpack(), type: .rapunzel))
+            case .belle:
+                var _v = _t.characters(at: index, type: BookReader.self)
+                characters.append(CharacterUnion(_v?.unpack(), type: .belle))
+            case .bookfan:
+                var _v = _t.characters(at: index, type: BookReader.self)
+                characters.append(CharacterUnion(_v?.unpack(), type: .bookfan))
+            default: break
+            }
+        }
+    }
+
+    init() {
+        characters = []
+    }
+
+}