mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-01 19:58:15 +00:00
fcf75449b8
Moves VTs from enums to structs to prevent empty enum generation, which would usually cause a compilation error.
2461 lines
130 KiB
Swift
2461 lines
130 KiB
Swift
// automatically generated by the FlatBuffers compiler, do not modify
|
|
// swiftlint:disable all
|
|
// swiftformat:disable all
|
|
|
|
#if canImport(Common)
|
|
import Common
|
|
#endif
|
|
|
|
import FlatBuffers
|
|
|
|
/// Composite components of Monster color.
|
|
public enum MyGame_Example_Color: UInt8, FlatbuffersVectorInitializable, Enum, Verifiable {
|
|
public typealias T = UInt8
|
|
public static var byteSize: Int { return MemoryLayout<UInt8>.size }
|
|
public var value: UInt8 { return self.rawValue }
|
|
case red = 1
|
|
/// \brief color Green
|
|
/// Green is bit_flag with value (1u << 1)
|
|
case green = 2
|
|
/// \brief color Blue (1u << 3)
|
|
case blue = 8
|
|
|
|
public static var max: MyGame_Example_Color { return .blue }
|
|
public static var min: MyGame_Example_Color { return .red }
|
|
}
|
|
|
|
extension MyGame_Example_Color: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .red: try container.encode("Red")
|
|
case .green: try container.encode("Green")
|
|
case .blue: try container.encode("Blue")
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum MyGame_Example_Race: Int8, FlatbuffersVectorInitializable, Enum, Verifiable {
|
|
public typealias T = Int8
|
|
public static var byteSize: Int { return MemoryLayout<Int8>.size }
|
|
public var value: Int8 { return self.rawValue }
|
|
case none_ = -1
|
|
case human = 0
|
|
case dwarf = 1
|
|
case elf = 2
|
|
|
|
public static var max: MyGame_Example_Race { return .elf }
|
|
public static var min: MyGame_Example_Race { return .none_ }
|
|
}
|
|
|
|
extension MyGame_Example_Race: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .none_: try container.encode("None")
|
|
case .human: try container.encode("Human")
|
|
case .dwarf: try container.encode("Dwarf")
|
|
case .elf: try container.encode("Elf")
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum MyGame_Example_LongEnum: UInt64, FlatbuffersVectorInitializable, Enum, Verifiable {
|
|
public typealias T = UInt64
|
|
public static var byteSize: Int { return MemoryLayout<UInt64>.size }
|
|
public var value: UInt64 { return self.rawValue }
|
|
case longone = 2
|
|
case longtwo = 4
|
|
case longbig = 1099511627776
|
|
|
|
public static var max: MyGame_Example_LongEnum { return .longbig }
|
|
public static var min: MyGame_Example_LongEnum { return .longone }
|
|
}
|
|
|
|
extension MyGame_Example_LongEnum: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .longone: try container.encode("LongOne")
|
|
case .longtwo: try container.encode("LongTwo")
|
|
case .longbig: try container.encode("LongBig")
|
|
}
|
|
}
|
|
}
|
|
|
|
public enum MyGame_Example_Any_: UInt8, FlatbuffersVectorInitializable, 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 monster = 1
|
|
case testsimpletablewithenum = 2
|
|
case mygameExample2Monster = 3
|
|
|
|
public static var max: MyGame_Example_Any_ { return .mygameExample2Monster }
|
|
public static var min: MyGame_Example_Any_ { return .none_ }
|
|
}
|
|
|
|
extension MyGame_Example_Any_: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .none_: try container.encode("NONE")
|
|
case .monster: try container.encode("Monster")
|
|
case .testsimpletablewithenum: try container.encode("TestSimpleTableWithEnum")
|
|
case .mygameExample2Monster: try container.encode("MyGame_Example2_Monster")
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_Any_Union {
|
|
public var type: MyGame_Example_Any_
|
|
public var value: NativeObject?
|
|
public init(_ v: NativeObject?, type: MyGame_Example_Any_) {
|
|
self.type = type
|
|
self.value = v
|
|
}
|
|
public func pack(builder: inout FlatBufferBuilder) -> Offset {
|
|
switch type {
|
|
case .monster:
|
|
var __obj = value as? MyGame_Example_MonsterT
|
|
return MyGame_Example_Monster.pack(&builder, obj: &__obj)
|
|
case .testsimpletablewithenum:
|
|
var __obj = value as? MyGame_Example_TestSimpleTableWithEnumT
|
|
return MyGame_Example_TestSimpleTableWithEnum.pack(&builder, obj: &__obj)
|
|
case .mygameExample2Monster:
|
|
var __obj = value as? MyGame_Example2_MonsterT
|
|
return MyGame_Example2_Monster.pack(&builder, obj: &__obj)
|
|
default: return Offset()
|
|
}
|
|
}
|
|
}
|
|
public enum MyGame_Example_AnyUniqueAliases: UInt8, FlatbuffersVectorInitializable, 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 m = 1
|
|
case ts = 2
|
|
case m2 = 3
|
|
|
|
public static var max: MyGame_Example_AnyUniqueAliases { return .m2 }
|
|
public static var min: MyGame_Example_AnyUniqueAliases { return .none_ }
|
|
}
|
|
|
|
extension MyGame_Example_AnyUniqueAliases: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .none_: try container.encode("NONE")
|
|
case .m: try container.encode("M")
|
|
case .ts: try container.encode("TS")
|
|
case .m2: try container.encode("M2")
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_AnyUniqueAliasesUnion {
|
|
public var type: MyGame_Example_AnyUniqueAliases
|
|
public var value: NativeObject?
|
|
public init(_ v: NativeObject?, type: MyGame_Example_AnyUniqueAliases) {
|
|
self.type = type
|
|
self.value = v
|
|
}
|
|
public func pack(builder: inout FlatBufferBuilder) -> Offset {
|
|
switch type {
|
|
case .m:
|
|
var __obj = value as? MyGame_Example_MonsterT
|
|
return MyGame_Example_Monster.pack(&builder, obj: &__obj)
|
|
case .ts:
|
|
var __obj = value as? MyGame_Example_TestSimpleTableWithEnumT
|
|
return MyGame_Example_TestSimpleTableWithEnum.pack(&builder, obj: &__obj)
|
|
case .m2:
|
|
var __obj = value as? MyGame_Example2_MonsterT
|
|
return MyGame_Example2_Monster.pack(&builder, obj: &__obj)
|
|
default: return Offset()
|
|
}
|
|
}
|
|
}
|
|
public enum MyGame_Example_AnyAmbiguousAliases: UInt8, FlatbuffersVectorInitializable, 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 m1 = 1
|
|
case m2 = 2
|
|
case m3 = 3
|
|
|
|
public static var max: MyGame_Example_AnyAmbiguousAliases { return .m3 }
|
|
public static var min: MyGame_Example_AnyAmbiguousAliases { return .none_ }
|
|
}
|
|
|
|
extension MyGame_Example_AnyAmbiguousAliases: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .none_: try container.encode("NONE")
|
|
case .m1: try container.encode("M1")
|
|
case .m2: try container.encode("M2")
|
|
case .m3: try container.encode("M3")
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_AnyAmbiguousAliasesUnion {
|
|
public var type: MyGame_Example_AnyAmbiguousAliases
|
|
public var value: NativeObject?
|
|
public init(_ v: NativeObject?, type: MyGame_Example_AnyAmbiguousAliases) {
|
|
self.type = type
|
|
self.value = v
|
|
}
|
|
public func pack(builder: inout FlatBufferBuilder) -> Offset {
|
|
switch type {
|
|
case .m1:
|
|
var __obj = value as? MyGame_Example_MonsterT
|
|
return MyGame_Example_Monster.pack(&builder, obj: &__obj)
|
|
case .m2:
|
|
var __obj = value as? MyGame_Example_MonsterT
|
|
return MyGame_Example_Monster.pack(&builder, obj: &__obj)
|
|
case .m3:
|
|
var __obj = value as? MyGame_Example_MonsterT
|
|
return MyGame_Example_Monster.pack(&builder, obj: &__obj)
|
|
default: return Offset()
|
|
}
|
|
}
|
|
}
|
|
public struct MyGame_Example_Test: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
|
|
private var _a: Int16
|
|
private var _b: Int8
|
|
private var padding0__: UInt8 = 0
|
|
|
|
public init(_ bb: ByteBuffer, o: Int32) {
|
|
self = bb.read(def: Self.self, position: Int(o))
|
|
}
|
|
|
|
public init(a: Int16, b: Int8) {
|
|
_a = a
|
|
_b = b
|
|
}
|
|
|
|
public init() {
|
|
_a = 0
|
|
_b = 0
|
|
}
|
|
|
|
public init(_ _t: borrowing MyGame_Example_Test_Mutable) {
|
|
_a = _t.a
|
|
_b = _t.b
|
|
}
|
|
|
|
public var a: Int16 { _a }
|
|
public var b: Int8 { _b }
|
|
|
|
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: MyGame_Example_Test.self)
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_Test: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case a = "a"
|
|
case b = "b"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
if a != 0 {
|
|
try container.encodeIfPresent(a, forKey: .a)
|
|
}
|
|
if b != 0 {
|
|
try container.encodeIfPresent(b, forKey: .b)
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_Test_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
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 a: Int16 { return _accessor.readBuffer(of: Int16.self, at: 0) }
|
|
@discardableResult public func mutate(a: Int16) -> Bool { return _accessor.mutate(a, index: 0) }
|
|
public var b: Int8 { return _accessor.readBuffer(of: Int8.self, at: 2) }
|
|
@discardableResult public func mutate(b: Int8) -> Bool { return _accessor.mutate(b, index: 2) }
|
|
|
|
public func unpack() -> MyGame_Example_Test {
|
|
return MyGame_Example_Test(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Test?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Test) -> Offset {
|
|
return builder.create(struct: obj)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_Vec3: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
|
|
private var _x: Float32
|
|
private var _y: Float32
|
|
private var _z: Float32
|
|
private var padding0__: UInt32 = 0
|
|
private var _test1: Double
|
|
private var _test2: UInt8
|
|
private var padding1__: UInt8 = 0
|
|
private var _test3: MyGame_Example_Test
|
|
private var padding2__: UInt16 = 0
|
|
|
|
public init(_ bb: ByteBuffer, o: Int32) {
|
|
self = bb.read(def: Self.self, position: Int(o))
|
|
}
|
|
|
|
public init(x: Float32, y: Float32, z: Float32, test1: Double, test2: MyGame_Example_Color, test3: MyGame_Example_Test) {
|
|
_x = x
|
|
_y = y
|
|
_z = z
|
|
_test1 = test1
|
|
_test2 = test2.value
|
|
_test3 = test3
|
|
}
|
|
|
|
public init() {
|
|
_x = 0.0
|
|
_y = 0.0
|
|
_z = 0.0
|
|
_test1 = 0.0
|
|
_test2 = 0
|
|
_test3 = MyGame_Example_Test()
|
|
}
|
|
|
|
public init(_ _t: borrowing MyGame_Example_Vec3_Mutable) {
|
|
_x = _t.x
|
|
_y = _t.y
|
|
_z = _t.z
|
|
_test1 = _t.test1
|
|
_test2 = _t.test2.value
|
|
let _vtest3 = _t.test3
|
|
_test3 = _vtest3.unpack()
|
|
}
|
|
|
|
public var x: Float32 { _x }
|
|
public var y: Float32 { _y }
|
|
public var z: Float32 { _z }
|
|
public var test1: Double { _test1 }
|
|
public var test2: MyGame_Example_Color { MyGame_Example_Color(rawValue: _test2)! }
|
|
public var test3: MyGame_Example_Test { _test3 }
|
|
|
|
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: MyGame_Example_Vec3.self)
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_Vec3: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case x = "x"
|
|
case y = "y"
|
|
case z = "z"
|
|
case test1 = "test1"
|
|
case test2 = "test2"
|
|
case test3 = "test3"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
if x != 0.0 {
|
|
try container.encodeIfPresent(x, forKey: .x)
|
|
}
|
|
if y != 0.0 {
|
|
try container.encodeIfPresent(y, forKey: .y)
|
|
}
|
|
if z != 0.0 {
|
|
try container.encodeIfPresent(z, forKey: .z)
|
|
}
|
|
if test1 != 0.0 {
|
|
try container.encodeIfPresent(test1, forKey: .test1)
|
|
}
|
|
if test2 != .red {
|
|
try container.encodeIfPresent(test2, forKey: .test2)
|
|
}
|
|
try container.encodeIfPresent(test3, forKey: .test3)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_Vec3_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
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 x: Float32 { return _accessor.readBuffer(of: Float32.self, at: 0) }
|
|
@discardableResult public func mutate(x: Float32) -> Bool { return _accessor.mutate(x, index: 0) }
|
|
public var y: Float32 { return _accessor.readBuffer(of: Float32.self, at: 4) }
|
|
@discardableResult public func mutate(y: Float32) -> Bool { return _accessor.mutate(y, index: 4) }
|
|
public var z: Float32 { return _accessor.readBuffer(of: Float32.self, at: 8) }
|
|
@discardableResult public func mutate(z: Float32) -> Bool { return _accessor.mutate(z, index: 8) }
|
|
public var test1: Double { return _accessor.readBuffer(of: Double.self, at: 16) }
|
|
@discardableResult public func mutate(test1: Double) -> Bool { return _accessor.mutate(test1, index: 16) }
|
|
public var test2: MyGame_Example_Color { return MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: 24)) ?? .red }
|
|
@discardableResult public func mutate(test2: MyGame_Example_Color) -> Bool { return _accessor.mutate(test2.rawValue, index: 24) }
|
|
public var test3: MyGame_Example_Test_Mutable { return MyGame_Example_Test_Mutable(_accessor.bb, o: _accessor.position + 26) }
|
|
|
|
public func unpack() -> MyGame_Example_Vec3 {
|
|
return MyGame_Example_Vec3(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Vec3) -> Offset {
|
|
return builder.create(struct: obj)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_Ability: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
|
|
private var _id: UInt32
|
|
private var _distance: UInt32
|
|
|
|
public init(_ bb: ByteBuffer, o: Int32) {
|
|
self = bb.read(def: Self.self, position: Int(o))
|
|
}
|
|
|
|
public init(id: UInt32, distance: UInt32) {
|
|
_id = id
|
|
_distance = distance
|
|
}
|
|
|
|
public init() {
|
|
_id = 0
|
|
_distance = 0
|
|
}
|
|
|
|
public init(_ _t: borrowing MyGame_Example_Ability_Mutable) {
|
|
_id = _t.id
|
|
_distance = _t.distance
|
|
}
|
|
|
|
public var id: UInt32 { _id }
|
|
public var distance: UInt32 { _distance }
|
|
|
|
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: MyGame_Example_Ability.self)
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_Ability: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case id = "id"
|
|
case distance = "distance"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
if id != 0 {
|
|
try container.encodeIfPresent(id, forKey: .id)
|
|
}
|
|
if distance != 0 {
|
|
try container.encodeIfPresent(distance, forKey: .distance)
|
|
}
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_Ability_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
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 id: UInt32 { return _accessor.readBuffer(of: UInt32.self, at: 0) }
|
|
@discardableResult public func mutate(id: UInt32) -> Bool { return _accessor.mutate(id, index: 0) }
|
|
public var distance: UInt32 { return _accessor.readBuffer(of: UInt32.self, at: 4) }
|
|
@discardableResult public func mutate(distance: UInt32) -> Bool { return _accessor.mutate(distance, index: 4) }
|
|
|
|
public func unpack() -> MyGame_Example_Ability {
|
|
return MyGame_Example_Ability(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Ability?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_Ability) -> Offset {
|
|
return builder.create(struct: obj)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_StructOfStructs: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
|
|
private var _a: MyGame_Example_Ability
|
|
private var _b: MyGame_Example_Test
|
|
private var _c: MyGame_Example_Ability
|
|
|
|
public init(_ bb: ByteBuffer, o: Int32) {
|
|
self = bb.read(def: Self.self, position: Int(o))
|
|
}
|
|
|
|
public init(a: MyGame_Example_Ability, b: MyGame_Example_Test, c: MyGame_Example_Ability) {
|
|
_a = a
|
|
_b = b
|
|
_c = c
|
|
}
|
|
|
|
public init() {
|
|
_a = MyGame_Example_Ability()
|
|
_b = MyGame_Example_Test()
|
|
_c = MyGame_Example_Ability()
|
|
}
|
|
|
|
public init(_ _t: borrowing MyGame_Example_StructOfStructs_Mutable) {
|
|
let _va = _t.a
|
|
_a = _va.unpack()
|
|
let _vb = _t.b
|
|
_b = _vb.unpack()
|
|
let _vc = _t.c
|
|
_c = _vc.unpack()
|
|
}
|
|
|
|
public var a: MyGame_Example_Ability { _a }
|
|
public var b: MyGame_Example_Test { _b }
|
|
public var c: MyGame_Example_Ability { _c }
|
|
|
|
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: MyGame_Example_StructOfStructs.self)
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_StructOfStructs: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case a = "a"
|
|
case b = "b"
|
|
case c = "c"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
try container.encodeIfPresent(a, forKey: .a)
|
|
try container.encodeIfPresent(b, forKey: .b)
|
|
try container.encodeIfPresent(c, forKey: .c)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_StructOfStructs_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
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 a: MyGame_Example_Ability_Mutable { return MyGame_Example_Ability_Mutable(_accessor.bb, o: _accessor.position + 0) }
|
|
public var b: MyGame_Example_Test_Mutable { return MyGame_Example_Test_Mutable(_accessor.bb, o: _accessor.position + 8) }
|
|
public var c: MyGame_Example_Ability_Mutable { return MyGame_Example_Ability_Mutable(_accessor.bb, o: _accessor.position + 12) }
|
|
|
|
public func unpack() -> MyGame_Example_StructOfStructs {
|
|
return MyGame_Example_StructOfStructs(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StructOfStructs?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StructOfStructs) -> Offset {
|
|
return builder.create(struct: obj)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_StructOfStructsOfStructs: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
|
|
private var _a: MyGame_Example_StructOfStructs
|
|
|
|
public init(_ bb: ByteBuffer, o: Int32) {
|
|
self = bb.read(def: Self.self, position: Int(o))
|
|
}
|
|
|
|
public init(a: MyGame_Example_StructOfStructs) {
|
|
_a = a
|
|
}
|
|
|
|
public init() {
|
|
_a = MyGame_Example_StructOfStructs()
|
|
}
|
|
|
|
public init(_ _t: borrowing MyGame_Example_StructOfStructsOfStructs_Mutable) {
|
|
let _va = _t.a
|
|
_a = _va.unpack()
|
|
}
|
|
|
|
public var a: MyGame_Example_StructOfStructs { _a }
|
|
|
|
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: MyGame_Example_StructOfStructsOfStructs.self)
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_StructOfStructsOfStructs: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case a = "a"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
try container.encodeIfPresent(a, forKey: .a)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_Example_StructOfStructsOfStructs_Mutable: FlatBufferStruct, FlatbuffersVectorInitializable {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
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 a: MyGame_Example_StructOfStructs_Mutable { return MyGame_Example_StructOfStructs_Mutable(_accessor.bb, o: _accessor.position + 0) }
|
|
|
|
public func unpack() -> MyGame_Example_StructOfStructsOfStructs {
|
|
return MyGame_Example_StructOfStructsOfStructs(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StructOfStructsOfStructs?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StructOfStructsOfStructs) -> Offset {
|
|
return builder.create(struct: obj)
|
|
}
|
|
}
|
|
|
|
public struct MyGame_InParentNamespace: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
public var __buffer: ByteBuffer! { return _accessor.bb }
|
|
private var _accessor: Table
|
|
|
|
public static var id: String { "MONS" }
|
|
public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_InParentNamespace.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
public static func startInParentNamespace(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 0) }
|
|
public static func endInParentNamespace(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
|
|
|
public func unpack() -> MyGame_InParentNamespaceT {
|
|
return MyGame_InParentNamespaceT(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_InParentNamespaceT) -> Offset {
|
|
let __root = MyGame_InParentNamespace.startInParentNamespace(&builder)
|
|
return MyGame_InParentNamespace.endInParentNamespace(&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)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
extension MyGame_InParentNamespace: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
}
|
|
}
|
|
|
|
public class MyGame_InParentNamespaceT: NativeObject {
|
|
|
|
|
|
public init(_ _t: borrowing MyGame_InParentNamespace) {
|
|
}
|
|
|
|
public init() {
|
|
}
|
|
|
|
public func serialize() -> ByteBuffer { return serialize(type: MyGame_InParentNamespace.self) }
|
|
|
|
}
|
|
public struct MyGame_Example2_Monster: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
public var __buffer: ByteBuffer! { return _accessor.bb }
|
|
private var _accessor: Table
|
|
|
|
public static var id: String { "MONS" }
|
|
public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_Example2_Monster.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 0) }
|
|
public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
|
|
|
public func unpack() -> MyGame_Example2_MonsterT {
|
|
return MyGame_Example2_MonsterT(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example2_MonsterT) -> Offset {
|
|
let __root = MyGame_Example2_Monster.startMonster(&builder)
|
|
return MyGame_Example2_Monster.endMonster(&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)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example2_Monster: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
}
|
|
}
|
|
|
|
public class MyGame_Example2_MonsterT: NativeObject {
|
|
|
|
|
|
public init(_ _t: borrowing MyGame_Example2_Monster) {
|
|
}
|
|
|
|
public init() {
|
|
}
|
|
|
|
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example2_Monster.self) }
|
|
|
|
}
|
|
internal struct MyGame_Example_TestSimpleTableWithEnum: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
internal var __buffer: ByteBuffer! { return _accessor.bb }
|
|
private var _accessor: Table
|
|
|
|
internal static var id: String { "MONS" }
|
|
internal static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_Example_TestSimpleTableWithEnum.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
internal init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
private struct VT {
|
|
static let color: VOffset = 4
|
|
}
|
|
|
|
internal var color: MyGame_Example_Color { let o = _accessor.offset(VT.color); return o == 0 ? .green : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .green }
|
|
@discardableResult internal func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VT.color); return _accessor.mutate(color.rawValue, index: o) }
|
|
internal static func startTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
|
|
internal static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VT.color) }
|
|
internal static func endTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
|
internal static func createTestSimpleTableWithEnum(
|
|
_ fbb: inout FlatBufferBuilder,
|
|
color: MyGame_Example_Color = .green
|
|
) -> Offset {
|
|
let __start = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&fbb)
|
|
MyGame_Example_TestSimpleTableWithEnum.add(color: color, &fbb)
|
|
return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&fbb, start: __start)
|
|
}
|
|
|
|
internal func unpack() -> MyGame_Example_TestSimpleTableWithEnumT {
|
|
return MyGame_Example_TestSimpleTableWithEnumT(self)
|
|
}
|
|
internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
internal static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TestSimpleTableWithEnumT) -> Offset {
|
|
let __root = MyGame_Example_TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&builder)
|
|
MyGame_Example_TestSimpleTableWithEnum.add(color: obj.color, &builder)
|
|
return MyGame_Example_TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&builder, start: __root)
|
|
}
|
|
|
|
internal 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: VT.color, fieldName: "color", required: false, type: MyGame_Example_Color.self)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_TestSimpleTableWithEnum: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case color = "color"
|
|
}
|
|
|
|
internal func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
if color != .green {
|
|
try container.encodeIfPresent(color, forKey: .color)
|
|
}
|
|
}
|
|
}
|
|
|
|
internal class MyGame_Example_TestSimpleTableWithEnumT: NativeObject {
|
|
|
|
internal var color: MyGame_Example_Color
|
|
|
|
internal init(_ _t: borrowing MyGame_Example_TestSimpleTableWithEnum) {
|
|
color = _t.color
|
|
}
|
|
|
|
internal init() {
|
|
color = .green
|
|
}
|
|
|
|
internal func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TestSimpleTableWithEnum.self) }
|
|
|
|
}
|
|
public struct MyGame_Example_Stat: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
public var __buffer: ByteBuffer! { return _accessor.bb }
|
|
private var _accessor: Table
|
|
|
|
public static var id: String { "MONS" }
|
|
public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_Example_Stat.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
private struct VT {
|
|
static let id: VOffset = 4
|
|
static let val: VOffset = 6
|
|
static let count: VOffset = 8
|
|
}
|
|
|
|
public var id: String? { let o = _accessor.offset(VT.id); return o == 0 ? nil : _accessor.string(at: o) }
|
|
public var idSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.id) }
|
|
public var val: Int64 { let o = _accessor.offset(VT.val); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
|
|
@discardableResult public func mutate(val: Int64) -> Bool {let o = _accessor.offset(VT.val); return _accessor.mutate(val, index: o) }
|
|
public var count: UInt16 { let o = _accessor.offset(VT.count); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
|
|
@discardableResult public func mutate(count: UInt16) -> Bool {let o = _accessor.offset(VT.count); return _accessor.mutate(count, index: o) }
|
|
public static func startStat(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 3) }
|
|
public static func add(id: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: id, at: VT.id) }
|
|
public static func add(val: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: val, def: 0, at: VT.val) }
|
|
public static func add(count: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: count, def: 0, at: VT.count) }
|
|
public static func endStat(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
|
public static func createStat(
|
|
_ fbb: inout FlatBufferBuilder,
|
|
idOffset id: Offset = Offset(),
|
|
val: Int64 = 0,
|
|
count: UInt16 = 0
|
|
) -> Offset {
|
|
let __start = MyGame_Example_Stat.startStat(&fbb)
|
|
MyGame_Example_Stat.add(id: id, &fbb)
|
|
MyGame_Example_Stat.add(val: val, &fbb)
|
|
MyGame_Example_Stat.add(count: count, &fbb)
|
|
return MyGame_Example_Stat.endStat(&fbb, start: __start)
|
|
}
|
|
public static func sortVectorOfStat(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
|
|
var off = offsets
|
|
off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 8, fbb: &fbb), Table.offset(Int32($0.o), vOffset: 8, fbb: &fbb), fbb: &fbb) < 0 }
|
|
return fbb.createVector(ofOffsets: off)
|
|
}
|
|
fileprivate static func lookupByKey(vector: Int32, key: UInt16, fbb: ByteBuffer) -> MyGame_Example_Stat? {
|
|
var span = fbb.read(def: Int32.self, position: Int(vector - 4))
|
|
var start: Int32 = 0
|
|
while span != 0 {
|
|
var middle = span / 2
|
|
let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
|
|
let comp = fbb.read(def: UInt16.self, position: Int(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 8, fbb: fbb)))
|
|
if comp > 0 {
|
|
span = middle
|
|
} else if comp < 0 {
|
|
middle += 1
|
|
start += middle
|
|
span -= middle
|
|
} else {
|
|
return MyGame_Example_Stat(fbb, o: tableOffset)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
public func unpack() -> MyGame_Example_StatT {
|
|
return MyGame_Example_StatT(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_StatT) -> Offset {
|
|
let __id: Offset
|
|
if let s = obj.id {
|
|
__id = builder.create(string: s)
|
|
} else {
|
|
__id = Offset()
|
|
}
|
|
|
|
let __root = MyGame_Example_Stat.startStat(&builder)
|
|
MyGame_Example_Stat.add(id: __id, &builder)
|
|
MyGame_Example_Stat.add(val: obj.val, &builder)
|
|
MyGame_Example_Stat.add(count: obj.count, &builder)
|
|
return MyGame_Example_Stat.endStat(&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: VT.id, fieldName: "id", required: false, type: ForwardOffset<String>.self)
|
|
try _v.visit(field: VT.val, fieldName: "val", required: false, type: Int64.self)
|
|
try _v.visit(field: VT.count, fieldName: "count", required: false, type: UInt16.self)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_Stat: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case id = "id"
|
|
case val = "val"
|
|
case count = "count"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
try container.encodeIfPresent(id, forKey: .id)
|
|
if val != 0 {
|
|
try container.encodeIfPresent(val, forKey: .val)
|
|
}
|
|
if count != 0 {
|
|
try container.encodeIfPresent(count, forKey: .count)
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MyGame_Example_StatT: NativeObject {
|
|
|
|
public var id: String?
|
|
public var val: Int64
|
|
public var count: UInt16
|
|
|
|
public init(_ _t: borrowing MyGame_Example_Stat) {
|
|
id = _t.id
|
|
val = _t.val
|
|
count = _t.count
|
|
}
|
|
|
|
public init() {
|
|
val = 0
|
|
count = 0
|
|
}
|
|
|
|
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Stat.self) }
|
|
|
|
}
|
|
public struct MyGame_Example_Referrable: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
public var __buffer: ByteBuffer! { return _accessor.bb }
|
|
private var _accessor: Table
|
|
|
|
public static var id: String { "MONS" }
|
|
public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_Example_Referrable.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
private struct VT {
|
|
static let id: VOffset = 4
|
|
}
|
|
|
|
public var id: UInt64 { let o = _accessor.offset(VT.id); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
|
|
@discardableResult public func mutate(id: UInt64) -> Bool {let o = _accessor.offset(VT.id); return _accessor.mutate(id, index: o) }
|
|
public static func startReferrable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
|
|
public static func add(id: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: id, def: 0, at: VT.id) }
|
|
public static func endReferrable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
|
public static func createReferrable(
|
|
_ fbb: inout FlatBufferBuilder,
|
|
id: UInt64 = 0
|
|
) -> Offset {
|
|
let __start = MyGame_Example_Referrable.startReferrable(&fbb)
|
|
MyGame_Example_Referrable.add(id: id, &fbb)
|
|
return MyGame_Example_Referrable.endReferrable(&fbb, start: __start)
|
|
}
|
|
public static func sortVectorOfReferrable(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
|
|
var off = offsets
|
|
off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 4, fbb: &fbb), Table.offset(Int32($0.o), vOffset: 4, fbb: &fbb), fbb: &fbb) < 0 }
|
|
return fbb.createVector(ofOffsets: off)
|
|
}
|
|
fileprivate static func lookupByKey(vector: Int32, key: UInt64, fbb: ByteBuffer) -> MyGame_Example_Referrable? {
|
|
var span = fbb.read(def: Int32.self, position: Int(vector - 4))
|
|
var start: Int32 = 0
|
|
while span != 0 {
|
|
var middle = span / 2
|
|
let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
|
|
let comp = fbb.read(def: UInt64.self, position: Int(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 4, fbb: fbb)))
|
|
if comp > 0 {
|
|
span = middle
|
|
} else if comp < 0 {
|
|
middle += 1
|
|
start += middle
|
|
span -= middle
|
|
} else {
|
|
return MyGame_Example_Referrable(fbb, o: tableOffset)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
public func unpack() -> MyGame_Example_ReferrableT {
|
|
return MyGame_Example_ReferrableT(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ReferrableT) -> Offset {
|
|
let __root = MyGame_Example_Referrable.startReferrable(&builder)
|
|
MyGame_Example_Referrable.add(id: obj.id, &builder)
|
|
return MyGame_Example_Referrable.endReferrable(&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: VT.id, fieldName: "id", required: false, type: UInt64.self)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_Referrable: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case id = "id"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
if id != 0 {
|
|
try container.encodeIfPresent(id, forKey: .id)
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MyGame_Example_ReferrableT: NativeObject {
|
|
|
|
public var id: UInt64
|
|
|
|
public init(_ _t: borrowing MyGame_Example_Referrable) {
|
|
id = _t.id
|
|
}
|
|
|
|
public init() {
|
|
id = 0
|
|
}
|
|
|
|
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Referrable.self) }
|
|
|
|
}
|
|
/// an example documentation comment: "monster object"
|
|
public struct MyGame_Example_Monster: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
public var __buffer: ByteBuffer! { return _accessor.bb }
|
|
private var _accessor: Table
|
|
|
|
public static var id: String { "MONS" }
|
|
public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_Example_Monster.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
private struct VT {
|
|
static let pos: VOffset = 4
|
|
static let mana: VOffset = 6
|
|
static let hp: VOffset = 8
|
|
static let name: VOffset = 10
|
|
static let inventory: VOffset = 14
|
|
static let color: VOffset = 16
|
|
static let testType: VOffset = 18
|
|
static let test: VOffset = 20
|
|
static let test4: VOffset = 22
|
|
static let testarrayofstring: VOffset = 24
|
|
static let testarrayoftables: VOffset = 26
|
|
static let enemy: VOffset = 28
|
|
static let testnestedflatbuffer: VOffset = 30
|
|
static let testempty: VOffset = 32
|
|
static let testbool: VOffset = 34
|
|
static let testhashs32Fnv1: VOffset = 36
|
|
static let testhashu32Fnv1: VOffset = 38
|
|
static let testhashs64Fnv1: VOffset = 40
|
|
static let testhashu64Fnv1: VOffset = 42
|
|
static let testhashs32Fnv1a: VOffset = 44
|
|
static let testhashu32Fnv1a: VOffset = 46
|
|
static let testhashs64Fnv1a: VOffset = 48
|
|
static let testhashu64Fnv1a: VOffset = 50
|
|
static let testarrayofbools: VOffset = 52
|
|
static let testf: VOffset = 54
|
|
static let testf2: VOffset = 56
|
|
static let testf3: VOffset = 58
|
|
static let testarrayofstring2: VOffset = 60
|
|
static let testarrayofsortedstruct: VOffset = 62
|
|
static let flex: VOffset = 64
|
|
static let test5: VOffset = 66
|
|
static let vectorOfLongs: VOffset = 68
|
|
static let vectorOfDoubles: VOffset = 70
|
|
static let parentNamespaceTest: VOffset = 72
|
|
static let vectorOfReferrables: VOffset = 74
|
|
static let singleWeakReference: VOffset = 76
|
|
static let vectorOfWeakReferences: VOffset = 78
|
|
static let vectorOfStrongReferrables: VOffset = 80
|
|
static let coOwningReference: VOffset = 82
|
|
static let vectorOfCoOwningReferences: VOffset = 84
|
|
static let nonOwningReference: VOffset = 86
|
|
static let vectorOfNonOwningReferences: VOffset = 88
|
|
static let anyUniqueType: VOffset = 90
|
|
static let anyUnique: VOffset = 92
|
|
static let anyAmbiguousType: VOffset = 94
|
|
static let anyAmbiguous: VOffset = 96
|
|
static let vectorOfEnums: VOffset = 98
|
|
static let signedEnum: VOffset = 100
|
|
static let testrequirednestedflatbuffer: VOffset = 102
|
|
static let scalarKeySortedTables: VOffset = 104
|
|
static let nativeInline: VOffset = 106
|
|
static let longEnumNonEnumDefault: VOffset = 108
|
|
static let longEnumNormalDefault: VOffset = 110
|
|
static let nanDefault: VOffset = 112
|
|
static let infDefault: VOffset = 114
|
|
static let positiveInfDefault: VOffset = 116
|
|
static let infinityDefault: VOffset = 118
|
|
static let positiveInfinityDefault: VOffset = 120
|
|
static let negativeInfDefault: VOffset = 122
|
|
static let negativeInfinityDefault: VOffset = 124
|
|
static let doubleInfDefault: VOffset = 126
|
|
}
|
|
|
|
public var pos: MyGame_Example_Vec3? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_Vec3.self, at: o) }
|
|
public var mutablePos: MyGame_Example_Vec3_Mutable? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : MyGame_Example_Vec3_Mutable(_accessor.bb, o: o + _accessor.position) }
|
|
public var mana: Int16 { let o = _accessor.offset(VT.mana); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
|
|
@discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VT.mana); return _accessor.mutate(mana, index: o) }
|
|
public var hp: Int16 { let o = _accessor.offset(VT.hp); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
|
|
@discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VT.hp); return _accessor.mutate(hp, index: o) }
|
|
public var name: String! { let o = _accessor.offset(VT.name); return _accessor.string(at: o) }
|
|
public var nameSegmentArray: [UInt8]! { return _accessor.getVector(at: VT.name) }
|
|
public var inventory: FlatbufferVector<UInt8> { return _accessor.vector(at: VT.inventory, byteSize: 1) }
|
|
public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VT.inventory); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
|
|
public func withUnsafePointerToInventory<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.inventory, body: body) }
|
|
public var color: MyGame_Example_Color { let o = _accessor.offset(VT.color); return o == 0 ? .blue : MyGame_Example_Color(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .blue }
|
|
@discardableResult public func mutate(color: MyGame_Example_Color) -> Bool {let o = _accessor.offset(VT.color); return _accessor.mutate(color.rawValue, index: o) }
|
|
public var testType: MyGame_Example_Any_ { let o = _accessor.offset(VT.testType); return o == 0 ? .none_ : MyGame_Example_Any_(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
|
|
public func test<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VT.test); return o == 0 ? nil : _accessor.union(o) }
|
|
public var test4: FlatbufferVector<MyGame_Example_Test> { return _accessor.vector(at: VT.test4, byteSize: 4) }
|
|
public var mutableTest4: FlatbufferVector<MyGame_Example_Test_Mutable> { return _accessor.vector(at: VT.test4, byteSize: 4) }
|
|
public func withUnsafePointerToTest4<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.test4, body: body) }
|
|
public var testarrayofstring: FlatbufferVector<String?> { return _accessor.vector(at: VT.testarrayofstring, byteSize: 4) }
|
|
/// an example documentation comment: this will end up in the generated code
|
|
/// multiline too
|
|
public var testarrayoftables: FlatbufferVector<MyGame_Example_Monster> { return _accessor.vector(at: VT.testarrayoftables, byteSize: 4) }
|
|
public func testarrayoftablesBy(key: String) -> MyGame_Example_Monster? { let o = _accessor.offset(VT.testarrayoftables); return o == 0 ? nil : MyGame_Example_Monster.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
|
|
public var enemy: MyGame_Example_Monster? { let o = _accessor.offset(VT.enemy); return o == 0 ? nil : MyGame_Example_Monster(_accessor.bb, o: _accessor.indirect(o + _accessor.position)) }
|
|
public var testnestedflatbuffer: FlatbufferVector<UInt8> { return _accessor.vector(at: VT.testnestedflatbuffer, byteSize: 1) }
|
|
public func mutate(testnestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VT.testnestedflatbuffer); return _accessor.directMutate(testnestedflatbuffer, index: _accessor.vector(at: o) + index * 1) }
|
|
public func withUnsafePointerToTestnestedflatbuffer<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.testnestedflatbuffer, body: body) }
|
|
public var testempty: MyGame_Example_Stat? { let o = _accessor.offset(VT.testempty); return o == 0 ? nil : MyGame_Example_Stat(_accessor.bb, o: _accessor.indirect(o + _accessor.position)) }
|
|
public var testbool: Bool { let o = _accessor.offset(VT.testbool); return o == 0 ? false : _accessor.readBuffer(of: Bool.self, at: o) }
|
|
@discardableResult public func mutate(testbool: Bool) -> Bool {let o = _accessor.offset(VT.testbool); return _accessor.mutate(testbool, index: o) }
|
|
public var testhashs32Fnv1: Int32 { let o = _accessor.offset(VT.testhashs32Fnv1); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
|
|
@discardableResult public func mutate(testhashs32Fnv1: Int32) -> Bool {let o = _accessor.offset(VT.testhashs32Fnv1); return _accessor.mutate(testhashs32Fnv1, index: o) }
|
|
public var testhashu32Fnv1: UInt32 { let o = _accessor.offset(VT.testhashu32Fnv1); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
|
|
@discardableResult public func mutate(testhashu32Fnv1: UInt32) -> Bool {let o = _accessor.offset(VT.testhashu32Fnv1); return _accessor.mutate(testhashu32Fnv1, index: o) }
|
|
public var testhashs64Fnv1: Int64 { let o = _accessor.offset(VT.testhashs64Fnv1); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
|
|
@discardableResult public func mutate(testhashs64Fnv1: Int64) -> Bool {let o = _accessor.offset(VT.testhashs64Fnv1); return _accessor.mutate(testhashs64Fnv1, index: o) }
|
|
public var testhashu64Fnv1: UInt64 { let o = _accessor.offset(VT.testhashu64Fnv1); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
|
|
@discardableResult public func mutate(testhashu64Fnv1: UInt64) -> Bool {let o = _accessor.offset(VT.testhashu64Fnv1); return _accessor.mutate(testhashu64Fnv1, index: o) }
|
|
public var testhashs32Fnv1a: Int32 { let o = _accessor.offset(VT.testhashs32Fnv1a); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
|
|
@discardableResult public func mutate(testhashs32Fnv1a: Int32) -> Bool {let o = _accessor.offset(VT.testhashs32Fnv1a); return _accessor.mutate(testhashs32Fnv1a, index: o) }
|
|
public var testhashu32Fnv1a: UInt32 { let o = _accessor.offset(VT.testhashu32Fnv1a); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
|
|
@discardableResult public func mutate(testhashu32Fnv1a: UInt32) -> Bool {let o = _accessor.offset(VT.testhashu32Fnv1a); return _accessor.mutate(testhashu32Fnv1a, index: o) }
|
|
public var testhashs64Fnv1a: Int64 { let o = _accessor.offset(VT.testhashs64Fnv1a); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
|
|
@discardableResult public func mutate(testhashs64Fnv1a: Int64) -> Bool {let o = _accessor.offset(VT.testhashs64Fnv1a); return _accessor.mutate(testhashs64Fnv1a, index: o) }
|
|
public var testhashu64Fnv1a: UInt64 { let o = _accessor.offset(VT.testhashu64Fnv1a); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
|
|
@discardableResult public func mutate(testhashu64Fnv1a: UInt64) -> Bool {let o = _accessor.offset(VT.testhashu64Fnv1a); return _accessor.mutate(testhashu64Fnv1a, index: o) }
|
|
public var testarrayofbools: FlatbufferVector<Bool> { return _accessor.vector(at: VT.testarrayofbools, byteSize: 1) }
|
|
public func mutate(testarrayofbools: Bool, at index: Int32) -> Bool { let o = _accessor.offset(VT.testarrayofbools); return _accessor.directMutate(testarrayofbools, index: _accessor.vector(at: o) + index * 1) }
|
|
public func withUnsafePointerToTestarrayofbools<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.testarrayofbools, body: body) }
|
|
public var testf: Float32 { let o = _accessor.offset(VT.testf); return o == 0 ? 3.14159 : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(testf: Float32) -> Bool {let o = _accessor.offset(VT.testf); return _accessor.mutate(testf, index: o) }
|
|
public var testf2: Float32 { let o = _accessor.offset(VT.testf2); return o == 0 ? 3.0 : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(testf2: Float32) -> Bool {let o = _accessor.offset(VT.testf2); return _accessor.mutate(testf2, index: o) }
|
|
public var testf3: Float32 { let o = _accessor.offset(VT.testf3); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(testf3: Float32) -> Bool {let o = _accessor.offset(VT.testf3); return _accessor.mutate(testf3, index: o) }
|
|
public var testarrayofstring2: FlatbufferVector<String?> { return _accessor.vector(at: VT.testarrayofstring2, byteSize: 4) }
|
|
public var testarrayofsortedstruct: FlatbufferVector<MyGame_Example_Ability> { return _accessor.vector(at: VT.testarrayofsortedstruct, byteSize: 8) }
|
|
public var mutableTestarrayofsortedstruct: FlatbufferVector<MyGame_Example_Ability_Mutable> { return _accessor.vector(at: VT.testarrayofsortedstruct, byteSize: 8) }
|
|
public func withUnsafePointerToTestarrayofsortedstruct<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.testarrayofsortedstruct, body: body) }
|
|
public var flex: FlatbufferVector<UInt8> { return _accessor.vector(at: VT.flex, byteSize: 1) }
|
|
public func mutate(flex: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VT.flex); return _accessor.directMutate(flex, index: _accessor.vector(at: o) + index * 1) }
|
|
public func withUnsafePointerToFlex<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.flex, body: body) }
|
|
public var test5: FlatbufferVector<MyGame_Example_Test> { return _accessor.vector(at: VT.test5, byteSize: 4) }
|
|
public var mutableTest5: FlatbufferVector<MyGame_Example_Test_Mutable> { return _accessor.vector(at: VT.test5, byteSize: 4) }
|
|
public func withUnsafePointerToTest5<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.test5, body: body) }
|
|
public var vectorOfLongs: FlatbufferVector<Int64> { return _accessor.vector(at: VT.vectorOfLongs, byteSize: 8) }
|
|
public func mutate(vectorOfLongs: Int64, at index: Int32) -> Bool { let o = _accessor.offset(VT.vectorOfLongs); return _accessor.directMutate(vectorOfLongs, index: _accessor.vector(at: o) + index * 8) }
|
|
public func withUnsafePointerToVectorOfLongs<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.vectorOfLongs, body: body) }
|
|
public var vectorOfDoubles: FlatbufferVector<Double> { return _accessor.vector(at: VT.vectorOfDoubles, byteSize: 8) }
|
|
public func mutate(vectorOfDoubles: Double, at index: Int32) -> Bool { let o = _accessor.offset(VT.vectorOfDoubles); return _accessor.directMutate(vectorOfDoubles, index: _accessor.vector(at: o) + index * 8) }
|
|
public func withUnsafePointerToVectorOfDoubles<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.vectorOfDoubles, body: body) }
|
|
public var parentNamespaceTest: MyGame_InParentNamespace? { let o = _accessor.offset(VT.parentNamespaceTest); return o == 0 ? nil : MyGame_InParentNamespace(_accessor.bb, o: _accessor.indirect(o + _accessor.position)) }
|
|
public var vectorOfReferrables: FlatbufferVector<MyGame_Example_Referrable> { return _accessor.vector(at: VT.vectorOfReferrables, byteSize: 4) }
|
|
public func vectorOfReferrablesBy(key: UInt64) -> MyGame_Example_Referrable? { let o = _accessor.offset(VT.vectorOfReferrables); return o == 0 ? nil : MyGame_Example_Referrable.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
|
|
public var singleWeakReference: UInt64 { let o = _accessor.offset(VT.singleWeakReference); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
|
|
@discardableResult public func mutate(singleWeakReference: UInt64) -> Bool {let o = _accessor.offset(VT.singleWeakReference); return _accessor.mutate(singleWeakReference, index: o) }
|
|
public var vectorOfWeakReferences: FlatbufferVector<UInt64> { return _accessor.vector(at: VT.vectorOfWeakReferences, byteSize: 8) }
|
|
public func mutate(vectorOfWeakReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VT.vectorOfWeakReferences); return _accessor.directMutate(vectorOfWeakReferences, index: _accessor.vector(at: o) + index * 8) }
|
|
public func withUnsafePointerToVectorOfWeakReferences<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.vectorOfWeakReferences, body: body) }
|
|
public var vectorOfStrongReferrables: FlatbufferVector<MyGame_Example_Referrable> { return _accessor.vector(at: VT.vectorOfStrongReferrables, byteSize: 4) }
|
|
public func vectorOfStrongReferrablesBy(key: UInt64) -> MyGame_Example_Referrable? { let o = _accessor.offset(VT.vectorOfStrongReferrables); return o == 0 ? nil : MyGame_Example_Referrable.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
|
|
public var coOwningReference: UInt64 { let o = _accessor.offset(VT.coOwningReference); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
|
|
@discardableResult public func mutate(coOwningReference: UInt64) -> Bool {let o = _accessor.offset(VT.coOwningReference); return _accessor.mutate(coOwningReference, index: o) }
|
|
public var vectorOfCoOwningReferences: FlatbufferVector<UInt64> { return _accessor.vector(at: VT.vectorOfCoOwningReferences, byteSize: 8) }
|
|
public func mutate(vectorOfCoOwningReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VT.vectorOfCoOwningReferences); return _accessor.directMutate(vectorOfCoOwningReferences, index: _accessor.vector(at: o) + index * 8) }
|
|
public func withUnsafePointerToVectorOfCoOwningReferences<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.vectorOfCoOwningReferences, body: body) }
|
|
public var nonOwningReference: UInt64 { let o = _accessor.offset(VT.nonOwningReference); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
|
|
@discardableResult public func mutate(nonOwningReference: UInt64) -> Bool {let o = _accessor.offset(VT.nonOwningReference); return _accessor.mutate(nonOwningReference, index: o) }
|
|
public var vectorOfNonOwningReferences: FlatbufferVector<UInt64> { return _accessor.vector(at: VT.vectorOfNonOwningReferences, byteSize: 8) }
|
|
public func mutate(vectorOfNonOwningReferences: UInt64, at index: Int32) -> Bool { let o = _accessor.offset(VT.vectorOfNonOwningReferences); return _accessor.directMutate(vectorOfNonOwningReferences, index: _accessor.vector(at: o) + index * 8) }
|
|
public func withUnsafePointerToVectorOfNonOwningReferences<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.vectorOfNonOwningReferences, body: body) }
|
|
public var anyUniqueType: MyGame_Example_AnyUniqueAliases { let o = _accessor.offset(VT.anyUniqueType); return o == 0 ? .none_ : MyGame_Example_AnyUniqueAliases(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
|
|
public func anyUnique<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VT.anyUnique); return o == 0 ? nil : _accessor.union(o) }
|
|
public var anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases { let o = _accessor.offset(VT.anyAmbiguousType); return o == 0 ? .none_ : MyGame_Example_AnyAmbiguousAliases(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
|
|
public func anyAmbiguous<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VT.anyAmbiguous); return o == 0 ? nil : _accessor.union(o) }
|
|
public var vectorOfEnums: FlatbufferVector<MyGame_Example_Color> { return _accessor.vector(at: VT.vectorOfEnums, byteSize: 1) }
|
|
public var signedEnum: MyGame_Example_Race { let o = _accessor.offset(VT.signedEnum); return o == 0 ? .none_ : MyGame_Example_Race(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
|
|
@discardableResult public func mutate(signedEnum: MyGame_Example_Race) -> Bool {let o = _accessor.offset(VT.signedEnum); return _accessor.mutate(signedEnum.rawValue, index: o) }
|
|
public var testrequirednestedflatbuffer: FlatbufferVector<UInt8> { return _accessor.vector(at: VT.testrequirednestedflatbuffer, byteSize: 1) }
|
|
public func mutate(testrequirednestedflatbuffer: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VT.testrequirednestedflatbuffer); return _accessor.directMutate(testrequirednestedflatbuffer, index: _accessor.vector(at: o) + index * 1) }
|
|
public func withUnsafePointerToTestrequirednestedflatbuffer<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.testrequirednestedflatbuffer, body: body) }
|
|
public var scalarKeySortedTables: FlatbufferVector<MyGame_Example_Stat> { return _accessor.vector(at: VT.scalarKeySortedTables, byteSize: 4) }
|
|
public func scalarKeySortedTablesBy(key: UInt16) -> MyGame_Example_Stat? { let o = _accessor.offset(VT.scalarKeySortedTables); return o == 0 ? nil : MyGame_Example_Stat.lookupByKey(vector: _accessor.vector(at: o), key: key, fbb: _accessor.bb) }
|
|
public var nativeInline: MyGame_Example_Test? { let o = _accessor.offset(VT.nativeInline); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_Test.self, at: o) }
|
|
public var mutableNativeInline: MyGame_Example_Test_Mutable? { let o = _accessor.offset(VT.nativeInline); return o == 0 ? nil : MyGame_Example_Test_Mutable(_accessor.bb, o: o + _accessor.position) }
|
|
public var longEnumNonEnumDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VT.longEnumNonEnumDefault); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
|
|
@discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VT.longEnumNonEnumDefault); return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) }
|
|
public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VT.longEnumNormalDefault); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
|
|
@discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VT.longEnumNormalDefault); return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) }
|
|
public var nanDefault: Float32 { let o = _accessor.offset(VT.nanDefault); return o == 0 ? .nan : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VT.nanDefault); return _accessor.mutate(nanDefault, index: o) }
|
|
public var infDefault: Float32 { let o = _accessor.offset(VT.infDefault); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VT.infDefault); return _accessor.mutate(infDefault, index: o) }
|
|
public var positiveInfDefault: Float32 { let o = _accessor.offset(VT.positiveInfDefault); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VT.positiveInfDefault); return _accessor.mutate(positiveInfDefault, index: o) }
|
|
public var infinityDefault: Float32 { let o = _accessor.offset(VT.infinityDefault); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VT.infinityDefault); return _accessor.mutate(infinityDefault, index: o) }
|
|
public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VT.positiveInfinityDefault); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VT.positiveInfinityDefault); return _accessor.mutate(positiveInfinityDefault, index: o) }
|
|
public var negativeInfDefault: Float32 { let o = _accessor.offset(VT.negativeInfDefault); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VT.negativeInfDefault); return _accessor.mutate(negativeInfDefault, index: o) }
|
|
public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VT.negativeInfinityDefault); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VT.negativeInfinityDefault); return _accessor.mutate(negativeInfinityDefault, index: o) }
|
|
public var doubleInfDefault: Double { let o = _accessor.offset(VT.doubleInfDefault); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
|
|
@discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VT.doubleInfDefault); return _accessor.mutate(doubleInfDefault, index: o) }
|
|
public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) }
|
|
public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VT.pos) }
|
|
public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VT.mana) }
|
|
public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VT.hp) }
|
|
public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
|
|
public static func addVectorOf(inventory: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VT.inventory) }
|
|
public static func add(color: MyGame_Example_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 8, at: VT.color) }
|
|
public static func add(testType: MyGame_Example_Any_, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testType.rawValue, def: 0, at: VT.testType) }
|
|
public static func add(test: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test, at: VT.test) }
|
|
public static func addVectorOf(test4: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test4, at: VT.test4) }
|
|
public static func startVectorOfTest4(_ size: Int, in builder: inout FlatBufferBuilder) {
|
|
builder.startVector(size * MemoryLayout<MyGame_Example_Test>.size, elementSize: MemoryLayout<MyGame_Example_Test>.alignment)
|
|
}
|
|
public static func addVectorOf(testarrayofstring: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring, at: VT.testarrayofstring) }
|
|
public static func addVectorOf(testarrayoftables: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayoftables, at: VT.testarrayoftables) }
|
|
public static func add(enemy: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: enemy, at: VT.enemy) }
|
|
public static func addVectorOf(testnestedflatbuffer: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testnestedflatbuffer, at: VT.testnestedflatbuffer) }
|
|
public static func add(testempty: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testempty, at: VT.testempty) }
|
|
public static func add(testbool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testbool, def: false,
|
|
at: VT.testbool) }
|
|
public static func add(testhashs32Fnv1: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs32Fnv1, def: 0, at: VT.testhashs32Fnv1) }
|
|
public static func add(testhashu32Fnv1: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu32Fnv1, def: 0, at: VT.testhashu32Fnv1) }
|
|
public static func add(testhashs64Fnv1: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs64Fnv1, def: 0, at: VT.testhashs64Fnv1) }
|
|
public static func add(testhashu64Fnv1: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu64Fnv1, def: 0, at: VT.testhashu64Fnv1) }
|
|
public static func add(testhashs32Fnv1a: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs32Fnv1a, def: 0, at: VT.testhashs32Fnv1a) }
|
|
public static func add(testhashu32Fnv1a: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu32Fnv1a, def: 0, at: VT.testhashu32Fnv1a) }
|
|
public static func add(testhashs64Fnv1a: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs64Fnv1a, def: 0, at: VT.testhashs64Fnv1a) }
|
|
public static func add(testhashu64Fnv1a: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu64Fnv1a, def: 0, at: VT.testhashu64Fnv1a) }
|
|
public static func addVectorOf(testarrayofbools: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofbools, at: VT.testarrayofbools) }
|
|
public static func add(testf: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf, def: 3.14159, at: VT.testf) }
|
|
public static func add(testf2: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf2, def: 3.0, at: VT.testf2) }
|
|
public static func add(testf3: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testf3, def: 0.0, at: VT.testf3) }
|
|
public static func addVectorOf(testarrayofstring2: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofstring2, at: VT.testarrayofstring2) }
|
|
public static func addVectorOf(testarrayofsortedstruct: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testarrayofsortedstruct, at: VT.testarrayofsortedstruct) }
|
|
public static func startVectorOfTestarrayofsortedstruct(_ size: Int, in builder: inout FlatBufferBuilder) {
|
|
builder.startVector(size * MemoryLayout<MyGame_Example_Ability>.size, elementSize: MemoryLayout<MyGame_Example_Ability>.alignment)
|
|
}
|
|
public static func addVectorOf(flex: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: flex, at: VT.flex) }
|
|
public static func addVectorOf(test5: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: test5, at: VT.test5) }
|
|
public static func startVectorOfTest5(_ size: Int, in builder: inout FlatBufferBuilder) {
|
|
builder.startVector(size * MemoryLayout<MyGame_Example_Test>.size, elementSize: MemoryLayout<MyGame_Example_Test>.alignment)
|
|
}
|
|
public static func addVectorOf(vectorOfLongs: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfLongs, at: VT.vectorOfLongs) }
|
|
public static func addVectorOf(vectorOfDoubles: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfDoubles, at: VT.vectorOfDoubles) }
|
|
public static func add(parentNamespaceTest: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: parentNamespaceTest, at: VT.parentNamespaceTest) }
|
|
public static func addVectorOf(vectorOfReferrables: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfReferrables, at: VT.vectorOfReferrables) }
|
|
public static func add(singleWeakReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: singleWeakReference, def: 0, at: VT.singleWeakReference) }
|
|
public static func addVectorOf(vectorOfWeakReferences: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfWeakReferences, at: VT.vectorOfWeakReferences) }
|
|
public static func addVectorOf(vectorOfStrongReferrables: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfStrongReferrables, at: VT.vectorOfStrongReferrables) }
|
|
public static func add(coOwningReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: coOwningReference, def: 0, at: VT.coOwningReference) }
|
|
public static func addVectorOf(vectorOfCoOwningReferences: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfCoOwningReferences, at: VT.vectorOfCoOwningReferences) }
|
|
public static func add(nonOwningReference: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nonOwningReference, def: 0, at: VT.nonOwningReference) }
|
|
public static func addVectorOf(vectorOfNonOwningReferences: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfNonOwningReferences, at: VT.vectorOfNonOwningReferences) }
|
|
public static func add(anyUniqueType: MyGame_Example_AnyUniqueAliases, _ fbb: inout FlatBufferBuilder) { fbb.add(element: anyUniqueType.rawValue, def: 0, at: VT.anyUniqueType) }
|
|
public static func add(anyUnique: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyUnique, at: VT.anyUnique) }
|
|
public static func add(anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases, _ fbb: inout FlatBufferBuilder) { fbb.add(element: anyAmbiguousType.rawValue, def: 0, at: VT.anyAmbiguousType) }
|
|
public static func add(anyAmbiguous: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: anyAmbiguous, at: VT.anyAmbiguous) }
|
|
public static func addVectorOf(vectorOfEnums: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfEnums, at: VT.vectorOfEnums) }
|
|
public static func add(signedEnum: MyGame_Example_Race, _ fbb: inout FlatBufferBuilder) { fbb.add(element: signedEnum.rawValue, def: -1, at: VT.signedEnum) }
|
|
public static func addVectorOf(testrequirednestedflatbuffer: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testrequirednestedflatbuffer, at: VT.testrequirednestedflatbuffer) }
|
|
public static func addVectorOf(scalarKeySortedTables: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: scalarKeySortedTables, at: VT.scalarKeySortedTables) }
|
|
public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VT.nativeInline) }
|
|
public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VT.longEnumNonEnumDefault) }
|
|
public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VT.longEnumNormalDefault) }
|
|
public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: .nan, at: VT.nanDefault) }
|
|
public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: .infinity, at: VT.infDefault) }
|
|
public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: .infinity, at: VT.positiveInfDefault) }
|
|
public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: .infinity, at: VT.infinityDefault) }
|
|
public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: .infinity, at: VT.positiveInfinityDefault) }
|
|
public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -.infinity, at: VT.negativeInfDefault) }
|
|
public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -.infinity, at: VT.negativeInfinityDefault) }
|
|
public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: .infinity, at: VT.doubleInfDefault) }
|
|
public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
|
|
public static func createMonster(
|
|
_ fbb: inout FlatBufferBuilder,
|
|
pos: MyGame_Example_Vec3? = nil,
|
|
mana: Int16 = 150,
|
|
hp: Int16 = 100,
|
|
nameOffset name: Offset,
|
|
inventoryVectorOffset inventory: Offset = Offset(),
|
|
color: MyGame_Example_Color = .blue,
|
|
testType: MyGame_Example_Any_ = .none_,
|
|
testOffset test: Offset = Offset(),
|
|
test4VectorOffset test4: Offset = Offset(),
|
|
testarrayofstringVectorOffset testarrayofstring: Offset = Offset(),
|
|
testarrayoftablesVectorOffset testarrayoftables: Offset = Offset(),
|
|
enemyOffset enemy: Offset = Offset(),
|
|
testnestedflatbufferVectorOffset testnestedflatbuffer: Offset = Offset(),
|
|
testemptyOffset testempty: Offset = Offset(),
|
|
testbool: Bool = false,
|
|
testhashs32Fnv1: Int32 = 0,
|
|
testhashu32Fnv1: UInt32 = 0,
|
|
testhashs64Fnv1: Int64 = 0,
|
|
testhashu64Fnv1: UInt64 = 0,
|
|
testhashs32Fnv1a: Int32 = 0,
|
|
testhashu32Fnv1a: UInt32 = 0,
|
|
testhashs64Fnv1a: Int64 = 0,
|
|
testhashu64Fnv1a: UInt64 = 0,
|
|
testarrayofboolsVectorOffset testarrayofbools: Offset = Offset(),
|
|
testf: Float32 = 3.14159,
|
|
testf2: Float32 = 3.0,
|
|
testf3: Float32 = 0.0,
|
|
testarrayofstring2VectorOffset testarrayofstring2: Offset = Offset(),
|
|
testarrayofsortedstructVectorOffset testarrayofsortedstruct: Offset = Offset(),
|
|
flexVectorOffset flex: Offset = Offset(),
|
|
test5VectorOffset test5: Offset = Offset(),
|
|
vectorOfLongsVectorOffset vectorOfLongs: Offset = Offset(),
|
|
vectorOfDoublesVectorOffset vectorOfDoubles: Offset = Offset(),
|
|
parentNamespaceTestOffset parentNamespaceTest: Offset = Offset(),
|
|
vectorOfReferrablesVectorOffset vectorOfReferrables: Offset = Offset(),
|
|
singleWeakReference: UInt64 = 0,
|
|
vectorOfWeakReferencesVectorOffset vectorOfWeakReferences: Offset = Offset(),
|
|
vectorOfStrongReferrablesVectorOffset vectorOfStrongReferrables: Offset = Offset(),
|
|
coOwningReference: UInt64 = 0,
|
|
vectorOfCoOwningReferencesVectorOffset vectorOfCoOwningReferences: Offset = Offset(),
|
|
nonOwningReference: UInt64 = 0,
|
|
vectorOfNonOwningReferencesVectorOffset vectorOfNonOwningReferences: Offset = Offset(),
|
|
anyUniqueType: MyGame_Example_AnyUniqueAliases = .none_,
|
|
anyUniqueOffset anyUnique: Offset = Offset(),
|
|
anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases = .none_,
|
|
anyAmbiguousOffset anyAmbiguous: Offset = Offset(),
|
|
vectorOfEnumsVectorOffset vectorOfEnums: Offset = Offset(),
|
|
signedEnum: MyGame_Example_Race = .none_,
|
|
testrequirednestedflatbufferVectorOffset testrequirednestedflatbuffer: Offset = Offset(),
|
|
scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset(),
|
|
nativeInline: MyGame_Example_Test? = nil,
|
|
longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone,
|
|
longEnumNormalDefault: MyGame_Example_LongEnum = .longone,
|
|
nanDefault: Float32 = .nan,
|
|
infDefault: Float32 = .infinity,
|
|
positiveInfDefault: Float32 = .infinity,
|
|
infinityDefault: Float32 = .infinity,
|
|
positiveInfinityDefault: Float32 = .infinity,
|
|
negativeInfDefault: Float32 = -.infinity,
|
|
negativeInfinityDefault: Float32 = -.infinity,
|
|
doubleInfDefault: Double = .infinity
|
|
) -> Offset {
|
|
let __start = MyGame_Example_Monster.startMonster(&fbb)
|
|
MyGame_Example_Monster.add(pos: pos, &fbb)
|
|
MyGame_Example_Monster.add(mana: mana, &fbb)
|
|
MyGame_Example_Monster.add(hp: hp, &fbb)
|
|
MyGame_Example_Monster.add(name: name, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(inventory: inventory, &fbb)
|
|
MyGame_Example_Monster.add(color: color, &fbb)
|
|
MyGame_Example_Monster.add(testType: testType, &fbb)
|
|
MyGame_Example_Monster.add(test: test, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(test4: test4, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofstring: testarrayofstring, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(testarrayoftables: testarrayoftables, &fbb)
|
|
MyGame_Example_Monster.add(enemy: enemy, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(testnestedflatbuffer: testnestedflatbuffer, &fbb)
|
|
MyGame_Example_Monster.add(testempty: testempty, &fbb)
|
|
MyGame_Example_Monster.add(testbool: testbool, &fbb)
|
|
MyGame_Example_Monster.add(testhashs32Fnv1: testhashs32Fnv1, &fbb)
|
|
MyGame_Example_Monster.add(testhashu32Fnv1: testhashu32Fnv1, &fbb)
|
|
MyGame_Example_Monster.add(testhashs64Fnv1: testhashs64Fnv1, &fbb)
|
|
MyGame_Example_Monster.add(testhashu64Fnv1: testhashu64Fnv1, &fbb)
|
|
MyGame_Example_Monster.add(testhashs32Fnv1a: testhashs32Fnv1a, &fbb)
|
|
MyGame_Example_Monster.add(testhashu32Fnv1a: testhashu32Fnv1a, &fbb)
|
|
MyGame_Example_Monster.add(testhashs64Fnv1a: testhashs64Fnv1a, &fbb)
|
|
MyGame_Example_Monster.add(testhashu64Fnv1a: testhashu64Fnv1a, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofbools: testarrayofbools, &fbb)
|
|
MyGame_Example_Monster.add(testf: testf, &fbb)
|
|
MyGame_Example_Monster.add(testf2: testf2, &fbb)
|
|
MyGame_Example_Monster.add(testf3: testf3, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofstring2: testarrayofstring2, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofsortedstruct: testarrayofsortedstruct, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(flex: flex, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(test5: test5, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfLongs: vectorOfLongs, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfDoubles: vectorOfDoubles, &fbb)
|
|
MyGame_Example_Monster.add(parentNamespaceTest: parentNamespaceTest, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfReferrables: vectorOfReferrables, &fbb)
|
|
MyGame_Example_Monster.add(singleWeakReference: singleWeakReference, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfWeakReferences: vectorOfWeakReferences, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfStrongReferrables: vectorOfStrongReferrables, &fbb)
|
|
MyGame_Example_Monster.add(coOwningReference: coOwningReference, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfCoOwningReferences: vectorOfCoOwningReferences, &fbb)
|
|
MyGame_Example_Monster.add(nonOwningReference: nonOwningReference, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfNonOwningReferences: vectorOfNonOwningReferences, &fbb)
|
|
MyGame_Example_Monster.add(anyUniqueType: anyUniqueType, &fbb)
|
|
MyGame_Example_Monster.add(anyUnique: anyUnique, &fbb)
|
|
MyGame_Example_Monster.add(anyAmbiguousType: anyAmbiguousType, &fbb)
|
|
MyGame_Example_Monster.add(anyAmbiguous: anyAmbiguous, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfEnums: vectorOfEnums, &fbb)
|
|
MyGame_Example_Monster.add(signedEnum: signedEnum, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: testrequirednestedflatbuffer, &fbb)
|
|
MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: scalarKeySortedTables, &fbb)
|
|
MyGame_Example_Monster.add(nativeInline: nativeInline, &fbb)
|
|
MyGame_Example_Monster.add(longEnumNonEnumDefault: longEnumNonEnumDefault, &fbb)
|
|
MyGame_Example_Monster.add(longEnumNormalDefault: longEnumNormalDefault, &fbb)
|
|
MyGame_Example_Monster.add(nanDefault: nanDefault, &fbb)
|
|
MyGame_Example_Monster.add(infDefault: infDefault, &fbb)
|
|
MyGame_Example_Monster.add(positiveInfDefault: positiveInfDefault, &fbb)
|
|
MyGame_Example_Monster.add(infinityDefault: infinityDefault, &fbb)
|
|
MyGame_Example_Monster.add(positiveInfinityDefault: positiveInfinityDefault, &fbb)
|
|
MyGame_Example_Monster.add(negativeInfDefault: negativeInfDefault, &fbb)
|
|
MyGame_Example_Monster.add(negativeInfinityDefault: negativeInfinityDefault, &fbb)
|
|
MyGame_Example_Monster.add(doubleInfDefault: doubleInfDefault, &fbb)
|
|
return MyGame_Example_Monster.endMonster(&fbb, start: __start)
|
|
}
|
|
public static func sortVectorOfMonster(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
|
|
var off = offsets
|
|
off.sort { Table.compare(Table.offset(Int32($1.o), vOffset: 10, fbb: &fbb), Table.offset(Int32($0.o), vOffset: 10, fbb: &fbb), fbb: &fbb) < 0 }
|
|
return fbb.createVector(ofOffsets: off)
|
|
}
|
|
fileprivate static func lookupByKey(vector: Int32, key: String, fbb: ByteBuffer) -> MyGame_Example_Monster? {
|
|
let key = key.utf8.map { $0 }
|
|
var span = fbb.read(def: Int32.self, position: Int(vector - 4))
|
|
var start: Int32 = 0
|
|
while span != 0 {
|
|
var middle = span / 2
|
|
let tableOffset = Table.indirect(vector + 4 * (start + middle), fbb)
|
|
let comp = Table.compare(Table.offset(Int32(fbb.capacity) - tableOffset, vOffset: 10, fbb: fbb), key, fbb: fbb)
|
|
if comp > 0 {
|
|
span = middle
|
|
} else if comp < 0 {
|
|
middle += 1
|
|
start += middle
|
|
span -= middle
|
|
} else {
|
|
return MyGame_Example_Monster(fbb, o: tableOffset)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
public func unpack() -> MyGame_Example_MonsterT {
|
|
return MyGame_Example_MonsterT(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_MonsterT) -> Offset {
|
|
let __name = builder.create(string: obj.name)
|
|
let __inventory = builder.createVector(obj.inventory)
|
|
let __test = obj.test?.pack(builder: &builder) ?? Offset()
|
|
MyGame_Example_Monster.startVectorOfTest4(obj.test4.count, in: &builder)
|
|
for val in obj.test4 {
|
|
builder.create(struct: val)
|
|
}
|
|
let __test4 = builder.endVector(len: obj.test4.count)
|
|
let __testarrayofstring = builder.createVector(ofStrings: obj.testarrayofstring.compactMap({ $0 }) )
|
|
var __testarrayoftables__: [Offset] = []
|
|
for var i in obj.testarrayoftables {
|
|
__testarrayoftables__.append(MyGame_Example_Monster.pack(&builder, obj: &i))
|
|
}
|
|
let __testarrayoftables = builder.createVector(ofOffsets: __testarrayoftables__)
|
|
let __enemy = MyGame_Example_Monster.pack(&builder, obj: &obj.enemy)
|
|
let __testnestedflatbuffer = builder.createVector(obj.testnestedflatbuffer)
|
|
let __testempty = MyGame_Example_Stat.pack(&builder, obj: &obj.testempty)
|
|
let __testarrayofbools = builder.createVector(obj.testarrayofbools)
|
|
let __testarrayofstring2 = builder.createVector(ofStrings: obj.testarrayofstring2.compactMap({ $0 }) )
|
|
MyGame_Example_Monster.startVectorOfTestarrayofsortedstruct(obj.testarrayofsortedstruct.count, in: &builder)
|
|
for val in obj.testarrayofsortedstruct {
|
|
builder.create(struct: val)
|
|
}
|
|
let __testarrayofsortedstruct = builder.endVector(len: obj.testarrayofsortedstruct.count)
|
|
let __flex = builder.createVector(obj.flex)
|
|
MyGame_Example_Monster.startVectorOfTest5(obj.test5.count, in: &builder)
|
|
for val in obj.test5 {
|
|
builder.create(struct: val)
|
|
}
|
|
let __test5 = builder.endVector(len: obj.test5.count)
|
|
let __vectorOfLongs = builder.createVector(obj.vectorOfLongs)
|
|
let __vectorOfDoubles = builder.createVector(obj.vectorOfDoubles)
|
|
let __parentNamespaceTest = MyGame_InParentNamespace.pack(&builder, obj: &obj.parentNamespaceTest)
|
|
var __vectorOfReferrables__: [Offset] = []
|
|
for var i in obj.vectorOfReferrables {
|
|
__vectorOfReferrables__.append(MyGame_Example_Referrable.pack(&builder, obj: &i))
|
|
}
|
|
let __vectorOfReferrables = builder.createVector(ofOffsets: __vectorOfReferrables__)
|
|
let __vectorOfWeakReferences = builder.createVector(obj.vectorOfWeakReferences)
|
|
var __vectorOfStrongReferrables__: [Offset] = []
|
|
for var i in obj.vectorOfStrongReferrables {
|
|
__vectorOfStrongReferrables__.append(MyGame_Example_Referrable.pack(&builder, obj: &i))
|
|
}
|
|
let __vectorOfStrongReferrables = builder.createVector(ofOffsets: __vectorOfStrongReferrables__)
|
|
let __vectorOfCoOwningReferences = builder.createVector(obj.vectorOfCoOwningReferences)
|
|
let __vectorOfNonOwningReferences = builder.createVector(obj.vectorOfNonOwningReferences)
|
|
let __anyUnique = obj.anyUnique?.pack(builder: &builder) ?? Offset()
|
|
let __anyAmbiguous = obj.anyAmbiguous?.pack(builder: &builder) ?? Offset()
|
|
let __vectorOfEnums = builder.createVector(obj.vectorOfEnums)
|
|
let __testrequirednestedflatbuffer = builder.createVector(obj.testrequirednestedflatbuffer)
|
|
var __scalarKeySortedTables__: [Offset] = []
|
|
for var i in obj.scalarKeySortedTables {
|
|
__scalarKeySortedTables__.append(MyGame_Example_Stat.pack(&builder, obj: &i))
|
|
}
|
|
let __scalarKeySortedTables = builder.createVector(ofOffsets: __scalarKeySortedTables__)
|
|
let __root = MyGame_Example_Monster.startMonster(&builder)
|
|
MyGame_Example_Monster.add(pos: obj.pos, &builder)
|
|
MyGame_Example_Monster.add(mana: obj.mana, &builder)
|
|
MyGame_Example_Monster.add(hp: obj.hp, &builder)
|
|
MyGame_Example_Monster.add(name: __name, &builder)
|
|
MyGame_Example_Monster.addVectorOf(inventory: __inventory, &builder)
|
|
MyGame_Example_Monster.add(color: obj.color, &builder)
|
|
if let o = obj.test?.type {
|
|
MyGame_Example_Monster.add(testType: o, &builder)
|
|
MyGame_Example_Monster.add(test: __test, &builder)
|
|
}
|
|
|
|
MyGame_Example_Monster.addVectorOf(test4: __test4, &builder)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofstring: __testarrayofstring, &builder)
|
|
MyGame_Example_Monster.addVectorOf(testarrayoftables: __testarrayoftables, &builder)
|
|
MyGame_Example_Monster.add(enemy: __enemy, &builder)
|
|
MyGame_Example_Monster.addVectorOf(testnestedflatbuffer: __testnestedflatbuffer, &builder)
|
|
MyGame_Example_Monster.add(testempty: __testempty, &builder)
|
|
MyGame_Example_Monster.add(testbool: obj.testbool, &builder)
|
|
MyGame_Example_Monster.add(testhashs32Fnv1: obj.testhashs32Fnv1, &builder)
|
|
MyGame_Example_Monster.add(testhashu32Fnv1: obj.testhashu32Fnv1, &builder)
|
|
MyGame_Example_Monster.add(testhashs64Fnv1: obj.testhashs64Fnv1, &builder)
|
|
MyGame_Example_Monster.add(testhashu64Fnv1: obj.testhashu64Fnv1, &builder)
|
|
MyGame_Example_Monster.add(testhashs32Fnv1a: obj.testhashs32Fnv1a, &builder)
|
|
MyGame_Example_Monster.add(testhashu32Fnv1a: obj.testhashu32Fnv1a, &builder)
|
|
MyGame_Example_Monster.add(testhashs64Fnv1a: obj.testhashs64Fnv1a, &builder)
|
|
MyGame_Example_Monster.add(testhashu64Fnv1a: obj.testhashu64Fnv1a, &builder)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofbools: __testarrayofbools, &builder)
|
|
MyGame_Example_Monster.add(testf: obj.testf, &builder)
|
|
MyGame_Example_Monster.add(testf2: obj.testf2, &builder)
|
|
MyGame_Example_Monster.add(testf3: obj.testf3, &builder)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofstring2: __testarrayofstring2, &builder)
|
|
MyGame_Example_Monster.addVectorOf(testarrayofsortedstruct: __testarrayofsortedstruct, &builder)
|
|
MyGame_Example_Monster.addVectorOf(flex: __flex, &builder)
|
|
MyGame_Example_Monster.addVectorOf(test5: __test5, &builder)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfLongs: __vectorOfLongs, &builder)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfDoubles: __vectorOfDoubles, &builder)
|
|
MyGame_Example_Monster.add(parentNamespaceTest: __parentNamespaceTest, &builder)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfReferrables: __vectorOfReferrables, &builder)
|
|
MyGame_Example_Monster.add(singleWeakReference: obj.singleWeakReference, &builder)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfWeakReferences: __vectorOfWeakReferences, &builder)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfStrongReferrables: __vectorOfStrongReferrables, &builder)
|
|
MyGame_Example_Monster.add(coOwningReference: obj.coOwningReference, &builder)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfCoOwningReferences: __vectorOfCoOwningReferences, &builder)
|
|
MyGame_Example_Monster.add(nonOwningReference: obj.nonOwningReference, &builder)
|
|
MyGame_Example_Monster.addVectorOf(vectorOfNonOwningReferences: __vectorOfNonOwningReferences, &builder)
|
|
if let o = obj.anyUnique?.type {
|
|
MyGame_Example_Monster.add(anyUniqueType: o, &builder)
|
|
MyGame_Example_Monster.add(anyUnique: __anyUnique, &builder)
|
|
}
|
|
|
|
if let o = obj.anyAmbiguous?.type {
|
|
MyGame_Example_Monster.add(anyAmbiguousType: o, &builder)
|
|
MyGame_Example_Monster.add(anyAmbiguous: __anyAmbiguous, &builder)
|
|
}
|
|
|
|
MyGame_Example_Monster.addVectorOf(vectorOfEnums: __vectorOfEnums, &builder)
|
|
MyGame_Example_Monster.add(signedEnum: obj.signedEnum, &builder)
|
|
MyGame_Example_Monster.addVectorOf(testrequirednestedflatbuffer: __testrequirednestedflatbuffer, &builder)
|
|
MyGame_Example_Monster.addVectorOf(scalarKeySortedTables: __scalarKeySortedTables, &builder)
|
|
MyGame_Example_Monster.add(nativeInline: obj.nativeInline, &builder)
|
|
MyGame_Example_Monster.add(longEnumNonEnumDefault: obj.longEnumNonEnumDefault, &builder)
|
|
MyGame_Example_Monster.add(longEnumNormalDefault: obj.longEnumNormalDefault, &builder)
|
|
MyGame_Example_Monster.add(nanDefault: obj.nanDefault, &builder)
|
|
MyGame_Example_Monster.add(infDefault: obj.infDefault, &builder)
|
|
MyGame_Example_Monster.add(positiveInfDefault: obj.positiveInfDefault, &builder)
|
|
MyGame_Example_Monster.add(infinityDefault: obj.infinityDefault, &builder)
|
|
MyGame_Example_Monster.add(positiveInfinityDefault: obj.positiveInfinityDefault, &builder)
|
|
MyGame_Example_Monster.add(negativeInfDefault: obj.negativeInfDefault, &builder)
|
|
MyGame_Example_Monster.add(negativeInfinityDefault: obj.negativeInfinityDefault, &builder)
|
|
MyGame_Example_Monster.add(doubleInfDefault: obj.doubleInfDefault, &builder)
|
|
return MyGame_Example_Monster.endMonster(&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: VT.pos, fieldName: "pos", required: false, type: MyGame_Example_Vec3.self)
|
|
try _v.visit(field: VT.mana, fieldName: "mana", required: false, type: Int16.self)
|
|
try _v.visit(field: VT.hp, fieldName: "hp", required: false, type: Int16.self)
|
|
try _v.visit(field: VT.name, fieldName: "name", required: true, type: ForwardOffset<String>.self)
|
|
try _v.visit(field: VT.inventory, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
|
|
try _v.visit(field: VT.color, fieldName: "color", required: false, type: MyGame_Example_Color.self)
|
|
try _v.visit(unionKey: VT.testType, unionField: VT.test, unionKeyName: "testType", fieldName: "test", required: false, completion: { (verifier, key: MyGame_Example_Any_, pos) in
|
|
switch key {
|
|
case .none_:
|
|
break // NOTE - SWIFT doesnt support none
|
|
case .monster:
|
|
try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
|
|
case .testsimpletablewithenum:
|
|
try ForwardOffset<MyGame_Example_TestSimpleTableWithEnum>.verify(&verifier, at: pos, of: MyGame_Example_TestSimpleTableWithEnum.self)
|
|
case .mygameExample2Monster:
|
|
try ForwardOffset<MyGame_Example2_Monster>.verify(&verifier, at: pos, of: MyGame_Example2_Monster.self)
|
|
}
|
|
})
|
|
try _v.visit(field: VT.test4, fieldName: "test4", required: false, type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>.self)
|
|
try _v.visit(field: VT.testarrayofstring, fieldName: "testarrayofstring", required: false, type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self)
|
|
try _v.visit(field: VT.testarrayoftables, fieldName: "testarrayoftables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Monster>, MyGame_Example_Monster>>.self)
|
|
try _v.visit(field: VT.enemy, fieldName: "enemy", required: false, type: ForwardOffset<MyGame_Example_Monster>.self)
|
|
try _v.visit(field: VT.testnestedflatbuffer, fieldName: "testnestedflatbuffer", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
|
|
try _v.visit(field: VT.testempty, fieldName: "testempty", required: false, type: ForwardOffset<MyGame_Example_Stat>.self)
|
|
try _v.visit(field: VT.testbool, fieldName: "testbool", required: false, type: Bool.self)
|
|
try _v.visit(field: VT.testhashs32Fnv1, fieldName: "testhashs32Fnv1", required: false, type: Int32.self)
|
|
try _v.visit(field: VT.testhashu32Fnv1, fieldName: "testhashu32Fnv1", required: false, type: UInt32.self)
|
|
try _v.visit(field: VT.testhashs64Fnv1, fieldName: "testhashs64Fnv1", required: false, type: Int64.self)
|
|
try _v.visit(field: VT.testhashu64Fnv1, fieldName: "testhashu64Fnv1", required: false, type: UInt64.self)
|
|
try _v.visit(field: VT.testhashs32Fnv1a, fieldName: "testhashs32Fnv1a", required: false, type: Int32.self)
|
|
try _v.visit(field: VT.testhashu32Fnv1a, fieldName: "testhashu32Fnv1a", required: false, type: UInt32.self)
|
|
try _v.visit(field: VT.testhashs64Fnv1a, fieldName: "testhashs64Fnv1a", required: false, type: Int64.self)
|
|
try _v.visit(field: VT.testhashu64Fnv1a, fieldName: "testhashu64Fnv1a", required: false, type: UInt64.self)
|
|
try _v.visit(field: VT.testarrayofbools, fieldName: "testarrayofbools", required: false, type: ForwardOffset<Vector<Bool, Bool>>.self)
|
|
try _v.visit(field: VT.testf, fieldName: "testf", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.testf2, fieldName: "testf2", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.testf3, fieldName: "testf3", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.testarrayofstring2, fieldName: "testarrayofstring2", required: false, type: ForwardOffset<Vector<ForwardOffset<String>, String>>.self)
|
|
try _v.visit(field: VT.testarrayofsortedstruct, fieldName: "testarrayofsortedstruct", required: false, type: ForwardOffset<Vector<MyGame_Example_Ability, MyGame_Example_Ability>>.self)
|
|
try _v.visit(field: VT.flex, fieldName: "flex", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
|
|
try _v.visit(field: VT.test5, fieldName: "test5", required: false, type: ForwardOffset<Vector<MyGame_Example_Test, MyGame_Example_Test>>.self)
|
|
try _v.visit(field: VT.vectorOfLongs, fieldName: "vectorOfLongs", required: false, type: ForwardOffset<Vector<Int64, Int64>>.self)
|
|
try _v.visit(field: VT.vectorOfDoubles, fieldName: "vectorOfDoubles", required: false, type: ForwardOffset<Vector<Double, Double>>.self)
|
|
try _v.visit(field: VT.parentNamespaceTest, fieldName: "parentNamespaceTest", required: false, type: ForwardOffset<MyGame_InParentNamespace>.self)
|
|
try _v.visit(field: VT.vectorOfReferrables, fieldName: "vectorOfReferrables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Referrable>, MyGame_Example_Referrable>>.self)
|
|
try _v.visit(field: VT.singleWeakReference, fieldName: "singleWeakReference", required: false, type: UInt64.self)
|
|
try _v.visit(field: VT.vectorOfWeakReferences, fieldName: "vectorOfWeakReferences", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
|
|
try _v.visit(field: VT.vectorOfStrongReferrables, fieldName: "vectorOfStrongReferrables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Referrable>, MyGame_Example_Referrable>>.self)
|
|
try _v.visit(field: VT.coOwningReference, fieldName: "coOwningReference", required: false, type: UInt64.self)
|
|
try _v.visit(field: VT.vectorOfCoOwningReferences, fieldName: "vectorOfCoOwningReferences", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
|
|
try _v.visit(field: VT.nonOwningReference, fieldName: "nonOwningReference", required: false, type: UInt64.self)
|
|
try _v.visit(field: VT.vectorOfNonOwningReferences, fieldName: "vectorOfNonOwningReferences", required: false, type: ForwardOffset<Vector<UInt64, UInt64>>.self)
|
|
try _v.visit(unionKey: VT.anyUniqueType, unionField: VT.anyUnique, unionKeyName: "anyUniqueType", fieldName: "anyUnique", required: false, completion: { (verifier, key: MyGame_Example_AnyUniqueAliases, pos) in
|
|
switch key {
|
|
case .none_:
|
|
break // NOTE - SWIFT doesnt support none
|
|
case .m:
|
|
try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
|
|
case .ts:
|
|
try ForwardOffset<MyGame_Example_TestSimpleTableWithEnum>.verify(&verifier, at: pos, of: MyGame_Example_TestSimpleTableWithEnum.self)
|
|
case .m2:
|
|
try ForwardOffset<MyGame_Example2_Monster>.verify(&verifier, at: pos, of: MyGame_Example2_Monster.self)
|
|
}
|
|
})
|
|
try _v.visit(unionKey: VT.anyAmbiguousType, unionField: VT.anyAmbiguous, unionKeyName: "anyAmbiguousType", fieldName: "anyAmbiguous", required: false, completion: { (verifier, key: MyGame_Example_AnyAmbiguousAliases, pos) in
|
|
switch key {
|
|
case .none_:
|
|
break // NOTE - SWIFT doesnt support none
|
|
case .m1:
|
|
try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
|
|
case .m2:
|
|
try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
|
|
case .m3:
|
|
try ForwardOffset<MyGame_Example_Monster>.verify(&verifier, at: pos, of: MyGame_Example_Monster.self)
|
|
}
|
|
})
|
|
try _v.visit(field: VT.vectorOfEnums, fieldName: "vectorOfEnums", required: false, type: ForwardOffset<Vector<MyGame_Example_Color, MyGame_Example_Color>>.self)
|
|
try _v.visit(field: VT.signedEnum, fieldName: "signedEnum", required: false, type: MyGame_Example_Race.self)
|
|
try _v.visit(field: VT.testrequirednestedflatbuffer, fieldName: "testrequirednestedflatbuffer", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
|
|
try _v.visit(field: VT.scalarKeySortedTables, fieldName: "scalarKeySortedTables", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Example_Stat>, MyGame_Example_Stat>>.self)
|
|
try _v.visit(field: VT.nativeInline, fieldName: "nativeInline", required: false, type: MyGame_Example_Test.self)
|
|
try _v.visit(field: VT.longEnumNonEnumDefault, fieldName: "longEnumNonEnumDefault", required: false, type: MyGame_Example_LongEnum.self)
|
|
try _v.visit(field: VT.longEnumNormalDefault, fieldName: "longEnumNormalDefault", required: false, type: MyGame_Example_LongEnum.self)
|
|
try _v.visit(field: VT.nanDefault, fieldName: "nanDefault", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.infDefault, fieldName: "infDefault", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.positiveInfDefault, fieldName: "positiveInfDefault", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.infinityDefault, fieldName: "infinityDefault", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.positiveInfinityDefault, fieldName: "positiveInfinityDefault", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.negativeInfDefault, fieldName: "negativeInfDefault", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.negativeInfinityDefault, fieldName: "negativeInfinityDefault", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.doubleInfDefault, fieldName: "doubleInfDefault", required: false, type: Double.self)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_Monster: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case pos = "pos"
|
|
case mana = "mana"
|
|
case hp = "hp"
|
|
case name = "name"
|
|
case inventory = "inventory"
|
|
case color = "color"
|
|
case testType = "test_type"
|
|
case test = "test"
|
|
case test4 = "test4"
|
|
case testarrayofstring = "testarrayofstring"
|
|
case testarrayoftables = "testarrayoftables"
|
|
case enemy = "enemy"
|
|
case testnestedflatbuffer = "testnestedflatbuffer"
|
|
case testempty = "testempty"
|
|
case testbool = "testbool"
|
|
case testhashs32Fnv1 = "testhashs32_fnv1"
|
|
case testhashu32Fnv1 = "testhashu32_fnv1"
|
|
case testhashs64Fnv1 = "testhashs64_fnv1"
|
|
case testhashu64Fnv1 = "testhashu64_fnv1"
|
|
case testhashs32Fnv1a = "testhashs32_fnv1a"
|
|
case testhashu32Fnv1a = "testhashu32_fnv1a"
|
|
case testhashs64Fnv1a = "testhashs64_fnv1a"
|
|
case testhashu64Fnv1a = "testhashu64_fnv1a"
|
|
case testarrayofbools = "testarrayofbools"
|
|
case testf = "testf"
|
|
case testf2 = "testf2"
|
|
case testf3 = "testf3"
|
|
case testarrayofstring2 = "testarrayofstring2"
|
|
case testarrayofsortedstruct = "testarrayofsortedstruct"
|
|
case flex = "flex"
|
|
case test5 = "test5"
|
|
case vectorOfLongs = "vector_of_longs"
|
|
case vectorOfDoubles = "vector_of_doubles"
|
|
case parentNamespaceTest = "parent_namespace_test"
|
|
case vectorOfReferrables = "vector_of_referrables"
|
|
case singleWeakReference = "single_weak_reference"
|
|
case vectorOfWeakReferences = "vector_of_weak_references"
|
|
case vectorOfStrongReferrables = "vector_of_strong_referrables"
|
|
case coOwningReference = "co_owning_reference"
|
|
case vectorOfCoOwningReferences = "vector_of_co_owning_references"
|
|
case nonOwningReference = "non_owning_reference"
|
|
case vectorOfNonOwningReferences = "vector_of_non_owning_references"
|
|
case anyUniqueType = "any_unique_type"
|
|
case anyUnique = "any_unique"
|
|
case anyAmbiguousType = "any_ambiguous_type"
|
|
case anyAmbiguous = "any_ambiguous"
|
|
case vectorOfEnums = "vector_of_enums"
|
|
case signedEnum = "signed_enum"
|
|
case testrequirednestedflatbuffer = "testrequirednestedflatbuffer"
|
|
case scalarKeySortedTables = "scalar_key_sorted_tables"
|
|
case nativeInline = "native_inline"
|
|
case longEnumNonEnumDefault = "long_enum_non_enum_default"
|
|
case longEnumNormalDefault = "long_enum_normal_default"
|
|
case nanDefault = "nan_default"
|
|
case infDefault = "inf_default"
|
|
case positiveInfDefault = "positive_inf_default"
|
|
case infinityDefault = "infinity_default"
|
|
case positiveInfinityDefault = "positive_infinity_default"
|
|
case negativeInfDefault = "negative_inf_default"
|
|
case negativeInfinityDefault = "negative_infinity_default"
|
|
case doubleInfDefault = "double_inf_default"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
try container.encodeIfPresent(pos, forKey: .pos)
|
|
if mana != 150 {
|
|
try container.encodeIfPresent(mana, forKey: .mana)
|
|
}
|
|
if hp != 100 {
|
|
try container.encodeIfPresent(hp, forKey: .hp)
|
|
}
|
|
try container.encodeIfPresent(name, forKey: .name)
|
|
try container.encodeIfPresent(inventory, forKey: .inventory)
|
|
if color != .blue {
|
|
try container.encodeIfPresent(color, forKey: .color)
|
|
}
|
|
if testType != .none_ {
|
|
try container.encodeIfPresent(testType, forKey: .testType)
|
|
}
|
|
switch testType {
|
|
case .monster:
|
|
let _v = test(type: MyGame_Example_Monster.self)
|
|
try container.encodeIfPresent(_v, forKey: .test)
|
|
case .testsimpletablewithenum:
|
|
let _v = test(type: MyGame_Example_TestSimpleTableWithEnum.self)
|
|
try container.encodeIfPresent(_v, forKey: .test)
|
|
case .mygameExample2Monster:
|
|
let _v = test(type: MyGame_Example2_Monster.self)
|
|
try container.encodeIfPresent(_v, forKey: .test)
|
|
default: break;
|
|
}
|
|
try container.encodeIfPresent(test4, forKey: .test4)
|
|
try container.encodeIfPresent(testarrayofstring, forKey: .testarrayofstring)
|
|
try container.encodeIfPresent(testarrayoftables, forKey: .testarrayoftables)
|
|
try container.encodeIfPresent(enemy, forKey: .enemy)
|
|
try container.encodeIfPresent(testnestedflatbuffer, forKey: .testnestedflatbuffer)
|
|
try container.encodeIfPresent(testempty, forKey: .testempty)
|
|
if testbool != false {
|
|
try container.encodeIfPresent(testbool, forKey: .testbool)
|
|
}
|
|
if testhashs32Fnv1 != 0 {
|
|
try container.encodeIfPresent(testhashs32Fnv1, forKey: .testhashs32Fnv1)
|
|
}
|
|
if testhashu32Fnv1 != 0 {
|
|
try container.encodeIfPresent(testhashu32Fnv1, forKey: .testhashu32Fnv1)
|
|
}
|
|
if testhashs64Fnv1 != 0 {
|
|
try container.encodeIfPresent(testhashs64Fnv1, forKey: .testhashs64Fnv1)
|
|
}
|
|
if testhashu64Fnv1 != 0 {
|
|
try container.encodeIfPresent(testhashu64Fnv1, forKey: .testhashu64Fnv1)
|
|
}
|
|
if testhashs32Fnv1a != 0 {
|
|
try container.encodeIfPresent(testhashs32Fnv1a, forKey: .testhashs32Fnv1a)
|
|
}
|
|
if testhashu32Fnv1a != 0 {
|
|
try container.encodeIfPresent(testhashu32Fnv1a, forKey: .testhashu32Fnv1a)
|
|
}
|
|
if testhashs64Fnv1a != 0 {
|
|
try container.encodeIfPresent(testhashs64Fnv1a, forKey: .testhashs64Fnv1a)
|
|
}
|
|
if testhashu64Fnv1a != 0 {
|
|
try container.encodeIfPresent(testhashu64Fnv1a, forKey: .testhashu64Fnv1a)
|
|
}
|
|
try container.encodeIfPresent(testarrayofbools, forKey: .testarrayofbools)
|
|
if testf != 3.14159 {
|
|
try container.encodeIfPresent(testf, forKey: .testf)
|
|
}
|
|
if testf2 != 3.0 {
|
|
try container.encodeIfPresent(testf2, forKey: .testf2)
|
|
}
|
|
if testf3 != 0.0 {
|
|
try container.encodeIfPresent(testf3, forKey: .testf3)
|
|
}
|
|
try container.encodeIfPresent(testarrayofstring2, forKey: .testarrayofstring2)
|
|
try container.encodeIfPresent(testarrayofsortedstruct, forKey: .testarrayofsortedstruct)
|
|
try container.encodeIfPresent(flex, forKey: .flex)
|
|
try container.encodeIfPresent(test5, forKey: .test5)
|
|
try container.encodeIfPresent(vectorOfLongs, forKey: .vectorOfLongs)
|
|
try container.encodeIfPresent(vectorOfDoubles, forKey: .vectorOfDoubles)
|
|
try container.encodeIfPresent(parentNamespaceTest, forKey: .parentNamespaceTest)
|
|
try container.encodeIfPresent(vectorOfReferrables, forKey: .vectorOfReferrables)
|
|
if singleWeakReference != 0 {
|
|
try container.encodeIfPresent(singleWeakReference, forKey: .singleWeakReference)
|
|
}
|
|
try container.encodeIfPresent(vectorOfWeakReferences, forKey: .vectorOfWeakReferences)
|
|
try container.encodeIfPresent(vectorOfStrongReferrables, forKey: .vectorOfStrongReferrables)
|
|
if coOwningReference != 0 {
|
|
try container.encodeIfPresent(coOwningReference, forKey: .coOwningReference)
|
|
}
|
|
try container.encodeIfPresent(vectorOfCoOwningReferences, forKey: .vectorOfCoOwningReferences)
|
|
if nonOwningReference != 0 {
|
|
try container.encodeIfPresent(nonOwningReference, forKey: .nonOwningReference)
|
|
}
|
|
try container.encodeIfPresent(vectorOfNonOwningReferences, forKey: .vectorOfNonOwningReferences)
|
|
if anyUniqueType != .none_ {
|
|
try container.encodeIfPresent(anyUniqueType, forKey: .anyUniqueType)
|
|
}
|
|
switch anyUniqueType {
|
|
case .m:
|
|
let _v = anyUnique(type: MyGame_Example_Monster.self)
|
|
try container.encodeIfPresent(_v, forKey: .anyUnique)
|
|
case .ts:
|
|
let _v = anyUnique(type: MyGame_Example_TestSimpleTableWithEnum.self)
|
|
try container.encodeIfPresent(_v, forKey: .anyUnique)
|
|
case .m2:
|
|
let _v = anyUnique(type: MyGame_Example2_Monster.self)
|
|
try container.encodeIfPresent(_v, forKey: .anyUnique)
|
|
default: break;
|
|
}
|
|
if anyAmbiguousType != .none_ {
|
|
try container.encodeIfPresent(anyAmbiguousType, forKey: .anyAmbiguousType)
|
|
}
|
|
switch anyAmbiguousType {
|
|
case .m1:
|
|
let _v = anyAmbiguous(type: MyGame_Example_Monster.self)
|
|
try container.encodeIfPresent(_v, forKey: .anyAmbiguous)
|
|
case .m2:
|
|
let _v = anyAmbiguous(type: MyGame_Example_Monster.self)
|
|
try container.encodeIfPresent(_v, forKey: .anyAmbiguous)
|
|
case .m3:
|
|
let _v = anyAmbiguous(type: MyGame_Example_Monster.self)
|
|
try container.encodeIfPresent(_v, forKey: .anyAmbiguous)
|
|
default: break;
|
|
}
|
|
try container.encodeIfPresent(vectorOfEnums, forKey: .vectorOfEnums)
|
|
if signedEnum != .none_ {
|
|
try container.encodeIfPresent(signedEnum, forKey: .signedEnum)
|
|
}
|
|
try container.encodeIfPresent(testrequirednestedflatbuffer, forKey: .testrequirednestedflatbuffer)
|
|
try container.encodeIfPresent(scalarKeySortedTables, forKey: .scalarKeySortedTables)
|
|
try container.encodeIfPresent(nativeInline, forKey: .nativeInline)
|
|
if longEnumNonEnumDefault != .longone {
|
|
try container.encodeIfPresent(longEnumNonEnumDefault, forKey: .longEnumNonEnumDefault)
|
|
}
|
|
if longEnumNormalDefault != .longone {
|
|
try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault)
|
|
}
|
|
if !nanDefault.isNaN {
|
|
try container.encodeIfPresent(nanDefault, forKey: .nanDefault)
|
|
}
|
|
if infDefault != .infinity {
|
|
try container.encodeIfPresent(infDefault, forKey: .infDefault)
|
|
}
|
|
if positiveInfDefault != .infinity {
|
|
try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault)
|
|
}
|
|
if infinityDefault != .infinity {
|
|
try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault)
|
|
}
|
|
if positiveInfinityDefault != .infinity {
|
|
try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault)
|
|
}
|
|
if negativeInfDefault != -.infinity {
|
|
try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault)
|
|
}
|
|
if negativeInfinityDefault != -.infinity {
|
|
try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault)
|
|
}
|
|
if doubleInfDefault != .infinity {
|
|
try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault)
|
|
}
|
|
}
|
|
}
|
|
|
|
public class MyGame_Example_MonsterT: NativeObject {
|
|
|
|
public var pos: MyGame_Example_Vec3?
|
|
public var mana: Int16
|
|
public var hp: Int16
|
|
public var name: String
|
|
public var inventory: [UInt8]
|
|
public var color: MyGame_Example_Color
|
|
public var test: MyGame_Example_Any_Union?
|
|
public var test4: [MyGame_Example_Test]
|
|
public var testarrayofstring: [String?]
|
|
public var testarrayoftables: [MyGame_Example_MonsterT?]
|
|
public var enemy: MyGame_Example_MonsterT?
|
|
public var testnestedflatbuffer: [UInt8]
|
|
public var testempty: MyGame_Example_StatT?
|
|
public var testbool: Bool
|
|
public var testhashs32Fnv1: Int32
|
|
public var testhashu32Fnv1: UInt32
|
|
public var testhashs64Fnv1: Int64
|
|
public var testhashu64Fnv1: UInt64
|
|
public var testhashs32Fnv1a: Int32
|
|
public var testhashu32Fnv1a: UInt32
|
|
public var testhashs64Fnv1a: Int64
|
|
public var testhashu64Fnv1a: UInt64
|
|
public var testarrayofbools: [Bool]
|
|
public var testf: Float32
|
|
public var testf2: Float32
|
|
public var testf3: Float32
|
|
public var testarrayofstring2: [String?]
|
|
public var testarrayofsortedstruct: [MyGame_Example_Ability]
|
|
public var flex: [UInt8]
|
|
public var test5: [MyGame_Example_Test]
|
|
public var vectorOfLongs: [Int64]
|
|
public var vectorOfDoubles: [Double]
|
|
public var parentNamespaceTest: MyGame_InParentNamespaceT?
|
|
public var vectorOfReferrables: [MyGame_Example_ReferrableT?]
|
|
public var singleWeakReference: UInt64
|
|
public var vectorOfWeakReferences: [UInt64]
|
|
public var vectorOfStrongReferrables: [MyGame_Example_ReferrableT?]
|
|
public var coOwningReference: UInt64
|
|
public var vectorOfCoOwningReferences: [UInt64]
|
|
public var nonOwningReference: UInt64
|
|
public var vectorOfNonOwningReferences: [UInt64]
|
|
public var anyUnique: MyGame_Example_AnyUniqueAliasesUnion?
|
|
public var anyAmbiguous: MyGame_Example_AnyAmbiguousAliasesUnion?
|
|
public var vectorOfEnums: [MyGame_Example_Color]
|
|
public var signedEnum: MyGame_Example_Race
|
|
public var testrequirednestedflatbuffer: [UInt8]
|
|
public var scalarKeySortedTables: [MyGame_Example_StatT?]
|
|
public var nativeInline: MyGame_Example_Test?
|
|
public var longEnumNonEnumDefault: MyGame_Example_LongEnum
|
|
public var longEnumNormalDefault: MyGame_Example_LongEnum
|
|
public var nanDefault: Float32
|
|
public var infDefault: Float32
|
|
public var positiveInfDefault: Float32
|
|
public var infinityDefault: Float32
|
|
public var positiveInfinityDefault: Float32
|
|
public var negativeInfDefault: Float32
|
|
public var negativeInfinityDefault: Float32
|
|
public var doubleInfDefault: Double
|
|
|
|
public init(_ _t: borrowing MyGame_Example_Monster) {
|
|
pos = _t.pos
|
|
mana = _t.mana
|
|
hp = _t.hp
|
|
name = _t.name
|
|
inventory = []
|
|
inventory.append(contentsOf: _t.inventory)
|
|
color = _t.color
|
|
switch _t.testType {
|
|
case .monster:
|
|
let _v = _t.test(type: MyGame_Example_Monster.self)
|
|
test = MyGame_Example_Any_Union(_v?.unpack(), type: .monster)
|
|
case .testsimpletablewithenum:
|
|
let _v = _t.test(type: MyGame_Example_TestSimpleTableWithEnum.self)
|
|
test = MyGame_Example_Any_Union(_v?.unpack(), type: .testsimpletablewithenum)
|
|
case .mygameExample2Monster:
|
|
let _v = _t.test(type: MyGame_Example2_Monster.self)
|
|
test = MyGame_Example_Any_Union(_v?.unpack(), type: .mygameExample2Monster)
|
|
default: break
|
|
}
|
|
test4 = []
|
|
test4.append(contentsOf: _t.test4)
|
|
testarrayofstring = []
|
|
testarrayofstring.append(contentsOf: _t.testarrayofstring)
|
|
testarrayoftables = []
|
|
for val in _t.testarrayoftables{
|
|
testarrayoftables.append(val.unpack())
|
|
}
|
|
enemy = _t.enemy?.unpack()
|
|
testnestedflatbuffer = []
|
|
testnestedflatbuffer.append(contentsOf: _t.testnestedflatbuffer)
|
|
testempty = _t.testempty?.unpack()
|
|
testbool = _t.testbool
|
|
testhashs32Fnv1 = _t.testhashs32Fnv1
|
|
testhashu32Fnv1 = _t.testhashu32Fnv1
|
|
testhashs64Fnv1 = _t.testhashs64Fnv1
|
|
testhashu64Fnv1 = _t.testhashu64Fnv1
|
|
testhashs32Fnv1a = _t.testhashs32Fnv1a
|
|
testhashu32Fnv1a = _t.testhashu32Fnv1a
|
|
testhashs64Fnv1a = _t.testhashs64Fnv1a
|
|
testhashu64Fnv1a = _t.testhashu64Fnv1a
|
|
testarrayofbools = []
|
|
testarrayofbools.append(contentsOf: _t.testarrayofbools)
|
|
testf = _t.testf
|
|
testf2 = _t.testf2
|
|
testf3 = _t.testf3
|
|
testarrayofstring2 = []
|
|
testarrayofstring2.append(contentsOf: _t.testarrayofstring2)
|
|
testarrayofsortedstruct = []
|
|
testarrayofsortedstruct.append(contentsOf: _t.testarrayofsortedstruct)
|
|
flex = []
|
|
flex.append(contentsOf: _t.flex)
|
|
test5 = []
|
|
test5.append(contentsOf: _t.test5)
|
|
vectorOfLongs = []
|
|
vectorOfLongs.append(contentsOf: _t.vectorOfLongs)
|
|
vectorOfDoubles = []
|
|
vectorOfDoubles.append(contentsOf: _t.vectorOfDoubles)
|
|
parentNamespaceTest = _t.parentNamespaceTest?.unpack()
|
|
vectorOfReferrables = []
|
|
for val in _t.vectorOfReferrables{
|
|
vectorOfReferrables.append(val.unpack())
|
|
}
|
|
singleWeakReference = _t.singleWeakReference
|
|
vectorOfWeakReferences = []
|
|
vectorOfWeakReferences.append(contentsOf: _t.vectorOfWeakReferences)
|
|
vectorOfStrongReferrables = []
|
|
for val in _t.vectorOfStrongReferrables{
|
|
vectorOfStrongReferrables.append(val.unpack())
|
|
}
|
|
coOwningReference = _t.coOwningReference
|
|
vectorOfCoOwningReferences = []
|
|
vectorOfCoOwningReferences.append(contentsOf: _t.vectorOfCoOwningReferences)
|
|
nonOwningReference = _t.nonOwningReference
|
|
vectorOfNonOwningReferences = []
|
|
vectorOfNonOwningReferences.append(contentsOf: _t.vectorOfNonOwningReferences)
|
|
switch _t.anyUniqueType {
|
|
case .m:
|
|
let _v = _t.anyUnique(type: MyGame_Example_Monster.self)
|
|
anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .m)
|
|
case .ts:
|
|
let _v = _t.anyUnique(type: MyGame_Example_TestSimpleTableWithEnum.self)
|
|
anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .ts)
|
|
case .m2:
|
|
let _v = _t.anyUnique(type: MyGame_Example2_Monster.self)
|
|
anyUnique = MyGame_Example_AnyUniqueAliasesUnion(_v?.unpack(), type: .m2)
|
|
default: break
|
|
}
|
|
switch _t.anyAmbiguousType {
|
|
case .m1:
|
|
let _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
|
|
anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m1)
|
|
case .m2:
|
|
let _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
|
|
anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m2)
|
|
case .m3:
|
|
let _v = _t.anyAmbiguous(type: MyGame_Example_Monster.self)
|
|
anyAmbiguous = MyGame_Example_AnyAmbiguousAliasesUnion(_v?.unpack(), type: .m3)
|
|
default: break
|
|
}
|
|
vectorOfEnums = []
|
|
vectorOfEnums.append(contentsOf: _t.vectorOfEnums)
|
|
signedEnum = _t.signedEnum
|
|
testrequirednestedflatbuffer = []
|
|
testrequirednestedflatbuffer.append(contentsOf: _t.testrequirednestedflatbuffer)
|
|
scalarKeySortedTables = []
|
|
for val in _t.scalarKeySortedTables{
|
|
scalarKeySortedTables.append(val.unpack())
|
|
}
|
|
nativeInline = _t.nativeInline
|
|
longEnumNonEnumDefault = _t.longEnumNonEnumDefault
|
|
longEnumNormalDefault = _t.longEnumNormalDefault
|
|
nanDefault = _t.nanDefault
|
|
infDefault = _t.infDefault
|
|
positiveInfDefault = _t.positiveInfDefault
|
|
infinityDefault = _t.infinityDefault
|
|
positiveInfinityDefault = _t.positiveInfinityDefault
|
|
negativeInfDefault = _t.negativeInfDefault
|
|
negativeInfinityDefault = _t.negativeInfinityDefault
|
|
doubleInfDefault = _t.doubleInfDefault
|
|
}
|
|
|
|
public init() {
|
|
pos = MyGame_Example_Vec3()
|
|
mana = 150
|
|
hp = 100
|
|
name = ""
|
|
inventory = []
|
|
color = .blue
|
|
test4 = []
|
|
testarrayofstring = []
|
|
testarrayoftables = []
|
|
enemy = MyGame_Example_MonsterT()
|
|
testnestedflatbuffer = []
|
|
testempty = MyGame_Example_StatT()
|
|
testbool = false
|
|
testhashs32Fnv1 = 0
|
|
testhashu32Fnv1 = 0
|
|
testhashs64Fnv1 = 0
|
|
testhashu64Fnv1 = 0
|
|
testhashs32Fnv1a = 0
|
|
testhashu32Fnv1a = 0
|
|
testhashs64Fnv1a = 0
|
|
testhashu64Fnv1a = 0
|
|
testarrayofbools = []
|
|
testf = 3.14159
|
|
testf2 = 3.0
|
|
testf3 = 0.0
|
|
testarrayofstring2 = []
|
|
testarrayofsortedstruct = []
|
|
flex = []
|
|
test5 = []
|
|
vectorOfLongs = []
|
|
vectorOfDoubles = []
|
|
parentNamespaceTest = MyGame_InParentNamespaceT()
|
|
vectorOfReferrables = []
|
|
singleWeakReference = 0
|
|
vectorOfWeakReferences = []
|
|
vectorOfStrongReferrables = []
|
|
coOwningReference = 0
|
|
vectorOfCoOwningReferences = []
|
|
nonOwningReference = 0
|
|
vectorOfNonOwningReferences = []
|
|
vectorOfEnums = []
|
|
signedEnum = .none_
|
|
testrequirednestedflatbuffer = []
|
|
scalarKeySortedTables = []
|
|
nativeInline = MyGame_Example_Test()
|
|
longEnumNonEnumDefault = .longone
|
|
longEnumNormalDefault = .longone
|
|
nanDefault = .nan
|
|
infDefault = .infinity
|
|
positiveInfDefault = .infinity
|
|
infinityDefault = .infinity
|
|
positiveInfinityDefault = .infinity
|
|
negativeInfDefault = -.infinity
|
|
negativeInfinityDefault = -.infinity
|
|
doubleInfDefault = .infinity
|
|
}
|
|
|
|
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }
|
|
|
|
}
|
|
public struct MyGame_Example_TypeAliases: FlatBufferTable, FlatbuffersVectorInitializable, Verifiable, ObjectAPIPacker {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
public var __buffer: ByteBuffer! { return _accessor.bb }
|
|
private var _accessor: Table
|
|
|
|
public static var id: String { "MONS" }
|
|
public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_Example_TypeAliases.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
private struct VT {
|
|
static let i8: VOffset = 4
|
|
static let u8: VOffset = 6
|
|
static let i16: VOffset = 8
|
|
static let u16: VOffset = 10
|
|
static let i32: VOffset = 12
|
|
static let u32: VOffset = 14
|
|
static let i64: VOffset = 16
|
|
static let u64: VOffset = 18
|
|
static let f32: VOffset = 20
|
|
static let f64: VOffset = 22
|
|
static let v8: VOffset = 24
|
|
static let vf64: VOffset = 26
|
|
}
|
|
|
|
public var i8: Int8 { let o = _accessor.offset(VT.i8); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
|
|
@discardableResult public func mutate(i8: Int8) -> Bool {let o = _accessor.offset(VT.i8); return _accessor.mutate(i8, index: o) }
|
|
public var u8: UInt8 { let o = _accessor.offset(VT.u8); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
|
|
@discardableResult public func mutate(u8: UInt8) -> Bool {let o = _accessor.offset(VT.u8); return _accessor.mutate(u8, index: o) }
|
|
public var i16: Int16 { let o = _accessor.offset(VT.i16); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
|
|
@discardableResult public func mutate(i16: Int16) -> Bool {let o = _accessor.offset(VT.i16); return _accessor.mutate(i16, index: o) }
|
|
public var u16: UInt16 { let o = _accessor.offset(VT.u16); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
|
|
@discardableResult public func mutate(u16: UInt16) -> Bool {let o = _accessor.offset(VT.u16); return _accessor.mutate(u16, index: o) }
|
|
public var i32: Int32 { let o = _accessor.offset(VT.i32); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
|
|
@discardableResult public func mutate(i32: Int32) -> Bool {let o = _accessor.offset(VT.i32); return _accessor.mutate(i32, index: o) }
|
|
public var u32: UInt32 { let o = _accessor.offset(VT.u32); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
|
|
@discardableResult public func mutate(u32: UInt32) -> Bool {let o = _accessor.offset(VT.u32); return _accessor.mutate(u32, index: o) }
|
|
public var i64: Int64 { let o = _accessor.offset(VT.i64); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
|
|
@discardableResult public func mutate(i64: Int64) -> Bool {let o = _accessor.offset(VT.i64); return _accessor.mutate(i64, index: o) }
|
|
public var u64: UInt64 { let o = _accessor.offset(VT.u64); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
|
|
@discardableResult public func mutate(u64: UInt64) -> Bool {let o = _accessor.offset(VT.u64); return _accessor.mutate(u64, index: o) }
|
|
public var f32: Float32 { let o = _accessor.offset(VT.f32); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
|
|
@discardableResult public func mutate(f32: Float32) -> Bool {let o = _accessor.offset(VT.f32); return _accessor.mutate(f32, index: o) }
|
|
public var f64: Double { let o = _accessor.offset(VT.f64); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
|
|
@discardableResult public func mutate(f64: Double) -> Bool {let o = _accessor.offset(VT.f64); return _accessor.mutate(f64, index: o) }
|
|
public var v8: FlatbufferVector<Int8> { return _accessor.vector(at: VT.v8, byteSize: 1) }
|
|
public func mutate(v8: Int8, at index: Int32) -> Bool { let o = _accessor.offset(VT.v8); return _accessor.directMutate(v8, index: _accessor.vector(at: o) + index * 1) }
|
|
public func withUnsafePointerToV8<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.v8, body: body) }
|
|
public var vf64: FlatbufferVector<Double> { return _accessor.vector(at: VT.vf64, byteSize: 8) }
|
|
public func mutate(vf64: Double, at index: Int32) -> Bool { let o = _accessor.offset(VT.vf64); return _accessor.directMutate(vf64, index: _accessor.vector(at: o) + index * 8) }
|
|
public func withUnsafePointerToVf64<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.vf64, body: body) }
|
|
public static func startTypeAliases(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 12) }
|
|
public static func add(i8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i8, def: 0, at: VT.i8) }
|
|
public static func add(u8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u8, def: 0, at: VT.u8) }
|
|
public static func add(i16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i16, def: 0, at: VT.i16) }
|
|
public static func add(u16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u16, def: 0, at: VT.u16) }
|
|
public static func add(i32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i32, def: 0, at: VT.i32) }
|
|
public static func add(u32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u32, def: 0, at: VT.u32) }
|
|
public static func add(i64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: i64, def: 0, at: VT.i64) }
|
|
public static func add(u64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: u64, def: 0, at: VT.u64) }
|
|
public static func add(f32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: f32, def: 0.0, at: VT.f32) }
|
|
public static func add(f64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: f64, def: 0.0, at: VT.f64) }
|
|
public static func addVectorOf(v8: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: v8, at: VT.v8) }
|
|
public static func addVectorOf(vf64: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vf64, at: VT.vf64) }
|
|
public static func endTypeAliases(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
|
public static func createTypeAliases(
|
|
_ fbb: inout FlatBufferBuilder,
|
|
i8: Int8 = 0,
|
|
u8: UInt8 = 0,
|
|
i16: Int16 = 0,
|
|
u16: UInt16 = 0,
|
|
i32: Int32 = 0,
|
|
u32: UInt32 = 0,
|
|
i64: Int64 = 0,
|
|
u64: UInt64 = 0,
|
|
f32: Float32 = 0.0,
|
|
f64: Double = 0.0,
|
|
v8VectorOffset v8: Offset = Offset(),
|
|
vf64VectorOffset vf64: Offset = Offset()
|
|
) -> Offset {
|
|
let __start = MyGame_Example_TypeAliases.startTypeAliases(&fbb)
|
|
MyGame_Example_TypeAliases.add(i8: i8, &fbb)
|
|
MyGame_Example_TypeAliases.add(u8: u8, &fbb)
|
|
MyGame_Example_TypeAliases.add(i16: i16, &fbb)
|
|
MyGame_Example_TypeAliases.add(u16: u16, &fbb)
|
|
MyGame_Example_TypeAliases.add(i32: i32, &fbb)
|
|
MyGame_Example_TypeAliases.add(u32: u32, &fbb)
|
|
MyGame_Example_TypeAliases.add(i64: i64, &fbb)
|
|
MyGame_Example_TypeAliases.add(u64: u64, &fbb)
|
|
MyGame_Example_TypeAliases.add(f32: f32, &fbb)
|
|
MyGame_Example_TypeAliases.add(f64: f64, &fbb)
|
|
MyGame_Example_TypeAliases.addVectorOf(v8: v8, &fbb)
|
|
MyGame_Example_TypeAliases.addVectorOf(vf64: vf64, &fbb)
|
|
return MyGame_Example_TypeAliases.endTypeAliases(&fbb, start: __start)
|
|
}
|
|
|
|
public func unpack() -> MyGame_Example_TypeAliasesT {
|
|
return MyGame_Example_TypeAliasesT(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_TypeAliasesT) -> Offset {
|
|
let __v8 = builder.createVector(obj.v8)
|
|
let __vf64 = builder.createVector(obj.vf64)
|
|
let __root = MyGame_Example_TypeAliases.startTypeAliases(&builder)
|
|
MyGame_Example_TypeAliases.add(i8: obj.i8, &builder)
|
|
MyGame_Example_TypeAliases.add(u8: obj.u8, &builder)
|
|
MyGame_Example_TypeAliases.add(i16: obj.i16, &builder)
|
|
MyGame_Example_TypeAliases.add(u16: obj.u16, &builder)
|
|
MyGame_Example_TypeAliases.add(i32: obj.i32, &builder)
|
|
MyGame_Example_TypeAliases.add(u32: obj.u32, &builder)
|
|
MyGame_Example_TypeAliases.add(i64: obj.i64, &builder)
|
|
MyGame_Example_TypeAliases.add(u64: obj.u64, &builder)
|
|
MyGame_Example_TypeAliases.add(f32: obj.f32, &builder)
|
|
MyGame_Example_TypeAliases.add(f64: obj.f64, &builder)
|
|
MyGame_Example_TypeAliases.addVectorOf(v8: __v8, &builder)
|
|
MyGame_Example_TypeAliases.addVectorOf(vf64: __vf64, &builder)
|
|
return MyGame_Example_TypeAliases.endTypeAliases(&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: VT.i8, fieldName: "i8", required: false, type: Int8.self)
|
|
try _v.visit(field: VT.u8, fieldName: "u8", required: false, type: UInt8.self)
|
|
try _v.visit(field: VT.i16, fieldName: "i16", required: false, type: Int16.self)
|
|
try _v.visit(field: VT.u16, fieldName: "u16", required: false, type: UInt16.self)
|
|
try _v.visit(field: VT.i32, fieldName: "i32", required: false, type: Int32.self)
|
|
try _v.visit(field: VT.u32, fieldName: "u32", required: false, type: UInt32.self)
|
|
try _v.visit(field: VT.i64, fieldName: "i64", required: false, type: Int64.self)
|
|
try _v.visit(field: VT.u64, fieldName: "u64", required: false, type: UInt64.self)
|
|
try _v.visit(field: VT.f32, fieldName: "f32", required: false, type: Float32.self)
|
|
try _v.visit(field: VT.f64, fieldName: "f64", required: false, type: Double.self)
|
|
try _v.visit(field: VT.v8, fieldName: "v8", required: false, type: ForwardOffset<Vector<Int8, Int8>>.self)
|
|
try _v.visit(field: VT.vf64, fieldName: "vf64", required: false, type: ForwardOffset<Vector<Double, Double>>.self)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
extension MyGame_Example_TypeAliases: Encodable {
|
|
enum CodingKeys: String, CodingKey {
|
|
case i8 = "i8"
|
|
case u8 = "u8"
|
|
case i16 = "i16"
|
|
case u16 = "u16"
|
|
case i32 = "i32"
|
|
case u32 = "u32"
|
|
case i64 = "i64"
|
|
case u64 = "u64"
|
|
case f32 = "f32"
|
|
case f64 = "f64"
|
|
case v8 = "v8"
|
|
case vf64 = "vf64"
|
|
}
|
|
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
if i8 != 0 {
|
|
try container.encodeIfPresent(i8, forKey: .i8)
|
|
}
|
|
if u8 != 0 {
|
|
try container.encodeIfPresent(u8, forKey: .u8)
|
|
}
|
|
if i16 != 0 {
|
|
try container.encodeIfPresent(i16, forKey: .i16)
|
|
}
|
|
if u16 != 0 {
|
|
try container.encodeIfPresent(u16, forKey: .u16)
|
|
}
|
|
if i32 != 0 {
|
|
try container.encodeIfPresent(i32, forKey: .i32)
|
|
}
|
|
if u32 != 0 {
|
|
try container.encodeIfPresent(u32, forKey: .u32)
|
|
}
|
|
if i64 != 0 {
|
|
try container.encodeIfPresent(i64, forKey: .i64)
|
|
}
|
|
if u64 != 0 {
|
|
try container.encodeIfPresent(u64, forKey: .u64)
|
|
}
|
|
if f32 != 0.0 {
|
|
try container.encodeIfPresent(f32, forKey: .f32)
|
|
}
|
|
if f64 != 0.0 {
|
|
try container.encodeIfPresent(f64, forKey: .f64)
|
|
}
|
|
try container.encodeIfPresent(v8, forKey: .v8)
|
|
try container.encodeIfPresent(vf64, forKey: .vf64)
|
|
}
|
|
}
|
|
|
|
public class MyGame_Example_TypeAliasesT: NativeObject {
|
|
|
|
public var i8: Int8
|
|
public var u8: UInt8
|
|
public var i16: Int16
|
|
public var u16: UInt16
|
|
public var i32: Int32
|
|
public var u32: UInt32
|
|
public var i64: Int64
|
|
public var u64: UInt64
|
|
public var f32: Float32
|
|
public var f64: Double
|
|
public var v8: [Int8]
|
|
public var vf64: [Double]
|
|
|
|
public init(_ _t: borrowing MyGame_Example_TypeAliases) {
|
|
i8 = _t.i8
|
|
u8 = _t.u8
|
|
i16 = _t.i16
|
|
u16 = _t.u16
|
|
i32 = _t.i32
|
|
u32 = _t.u32
|
|
i64 = _t.i64
|
|
u64 = _t.u64
|
|
f32 = _t.f32
|
|
f64 = _t.f64
|
|
v8 = []
|
|
v8.append(contentsOf: _t.v8)
|
|
vf64 = []
|
|
vf64.append(contentsOf: _t.vf64)
|
|
}
|
|
|
|
public init() {
|
|
i8 = 0
|
|
u8 = 0
|
|
i16 = 0
|
|
u16 = 0
|
|
i32 = 0
|
|
u32 = 0
|
|
i64 = 0
|
|
u64 = 0
|
|
f32 = 0.0
|
|
f64 = 0.0
|
|
v8 = []
|
|
vf64 = []
|
|
}
|
|
|
|
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_TypeAliases.self) }
|
|
|
|
}
|