mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-15 16:57:29 +00:00
360 lines
14 KiB
Swift
360 lines
14 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
|
|
|
|
#if compiler(>=6.2)
|
|
public enum MyGame_Example_TestEnum: 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 a = 0
|
|
case b = 1
|
|
case c = 2
|
|
|
|
public static var max: MyGame_Example_TestEnum { return .c }
|
|
public static var min: MyGame_Example_TestEnum { return .a }
|
|
}
|
|
|
|
extension MyGame_Example_TestEnum: Encodable {
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.singleValueContainer()
|
|
switch self {
|
|
case .a: try container.encode("A")
|
|
case .b: try container.encode("B")
|
|
case .c: try container.encode("C")
|
|
}
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
public struct MyGame_Example_NestedStruct: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
|
|
private var _a: InlineArray<2, Int32>
|
|
private var _b: Int8
|
|
private var _c: InlineArray<2, Int8>
|
|
private var padding0__: UInt8 = 0
|
|
private var padding1__: UInt32 = 0
|
|
private var _d: InlineArray<2, Int64>
|
|
|
|
public init(_ bb: ByteBuffer, o: Int32) {
|
|
self = bb.read(def: Self.self, position: Int(o))
|
|
}
|
|
|
|
public init(a: InlineArray<2, Int32>, b: MyGame_Example_TestEnum, c: InlineArray<2, Int8>, d: InlineArray<2, Int64>) {
|
|
_a = a
|
|
_b = b.value
|
|
_c = c
|
|
_d = d
|
|
}
|
|
|
|
public init() {
|
|
_a = InlineArray(repeating: 0)
|
|
_b = 0
|
|
_c = InlineArray(repeating: 0)
|
|
_d = InlineArray(repeating: 0)
|
|
}
|
|
|
|
public init(_ _t: borrowing MyGame_Example_NestedStruct_Mutable) {
|
|
let _va = _t.a
|
|
_a = InlineArray { _va[$0] }
|
|
_b = _t.b.value
|
|
let _vc = _t.c
|
|
_c = InlineArray { _vc[$0].rawValue }
|
|
let _vd = _t.d
|
|
_d = InlineArray { _vd[$0] }
|
|
}
|
|
|
|
public var a: InlineArray<2, Int32> { _a }
|
|
public var b: MyGame_Example_TestEnum { MyGame_Example_TestEnum(rawValue: _b)! }
|
|
public var c: InlineArray<2, MyGame_Example_TestEnum> { InlineArray { MyGame_Example_TestEnum(rawValue: _c[$0])! } }
|
|
public var d: InlineArray<2, Int64> { _d }
|
|
|
|
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_NestedStruct.self)
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
extension MyGame_Example_NestedStruct: Encodable {
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case a = "a"
|
|
case b = "b"
|
|
case c = "c"
|
|
case d = "d"
|
|
}
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
var aContainer = container.nestedUnkeyedContainer(forKey: .a)
|
|
for index in a.startIndex..<a.endIndex {
|
|
try aContainer.encode(a[index])
|
|
}
|
|
if b != .a {
|
|
try container.encodeIfPresent(b, forKey: .b)
|
|
}
|
|
var cContainer = container.nestedUnkeyedContainer(forKey: .c)
|
|
for index in c.startIndex..<c.endIndex {
|
|
try cContainer.encode(c[index])
|
|
}
|
|
var dContainer = container.nestedUnkeyedContainer(forKey: .d)
|
|
for index in d.startIndex..<d.endIndex {
|
|
try dContainer.encode(d[index])
|
|
}
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
public struct MyGame_Example_NestedStruct_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: FlatbufferVector<Int32> { return _accessor.vector(at: 0, count: 2, size: 4) }
|
|
@discardableResult public func mutate(a: Int32, at index: Int32) -> Bool { return _accessor.mutate(a, index: 0 + (index * 4)) }
|
|
public var b: MyGame_Example_TestEnum { return MyGame_Example_TestEnum(rawValue: _accessor.readBuffer(of: Int8.self, at: 8)) ?? .a }
|
|
@discardableResult public func mutate(b: MyGame_Example_TestEnum) -> Bool { return _accessor.mutate(b.rawValue, index: 8) }
|
|
public var c: FlatbufferVector<MyGame_Example_TestEnum> { return _accessor.vector(at: 9, count: 2, size: 1) }
|
|
@discardableResult public func mutate(c: MyGame_Example_TestEnum, at index: Int32) -> Bool { return _accessor.mutate(c.rawValue, index: 9 + (index * 1)) }
|
|
public var d: FlatbufferVector<Int64> { return _accessor.vector(at: 16, count: 2, size: 8) }
|
|
@discardableResult public func mutate(d: Int64, at index: Int32) -> Bool { return _accessor.mutate(d, index: 16 + (index * 8)) }
|
|
|
|
public func unpack() -> MyGame_Example_NestedStruct {
|
|
return MyGame_Example_NestedStruct(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_NestedStruct?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_NestedStruct) -> Offset {
|
|
return builder.create(struct: obj)
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
public struct MyGame_Example_ArrayStruct: NativeStruct, FlatbuffersVectorInitializable, Verifiable, FlatbuffersInitializable, NativeObject {
|
|
|
|
static func validateVersion() { FlatBuffersVersion_25_12_19() }
|
|
|
|
private var _a: Float32
|
|
private var _b: InlineArray<15, Int32>
|
|
private var _c: Int8
|
|
private var padding0__: UInt8 = 0
|
|
private var padding1__: UInt16 = 0
|
|
private var padding2__: UInt32 = 0
|
|
private var _d: InlineArray<2, MyGame_Example_NestedStruct>
|
|
private var _e: Int32
|
|
private var padding3__: UInt32 = 0
|
|
private var _f: InlineArray<2, Int64>
|
|
|
|
public init(_ bb: ByteBuffer, o: Int32) {
|
|
self = bb.read(def: Self.self, position: Int(o))
|
|
}
|
|
|
|
public init(a: Float32, b: InlineArray<15, Int32>, c: Int8, d: InlineArray<2, MyGame_Example_NestedStruct>, e: Int32, f: InlineArray<2, Int64>) {
|
|
_a = a
|
|
_b = b
|
|
_c = c
|
|
_d = d
|
|
_e = e
|
|
_f = f
|
|
}
|
|
|
|
public init() {
|
|
_a = 0.0
|
|
_b = InlineArray(repeating: 0)
|
|
_c = 0
|
|
_d = InlineArray(repeating: MyGame_Example_NestedStruct())
|
|
_e = 0
|
|
_f = InlineArray(repeating: 0)
|
|
}
|
|
|
|
public init(_ _t: borrowing MyGame_Example_ArrayStruct_Mutable) {
|
|
_a = _t.a
|
|
let _vb = _t.b
|
|
_b = InlineArray { _vb[$0] }
|
|
_c = _t.c
|
|
let _vd = _t.d
|
|
_d = InlineArray { _vd[$0].unpack() }
|
|
_e = _t.e
|
|
let _vf = _t.f
|
|
_f = InlineArray { _vf[$0] }
|
|
}
|
|
|
|
public var a: Float32 { _a }
|
|
public var b: InlineArray<15, Int32> { _b }
|
|
public var c: Int8 { _c }
|
|
public var d: InlineArray<2, MyGame_Example_NestedStruct> { _d }
|
|
public var e: Int32 { _e }
|
|
public var f: InlineArray<2, Int64> { _f }
|
|
|
|
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_ArrayStruct.self)
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
extension MyGame_Example_ArrayStruct: Encodable {
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case a = "a"
|
|
case b = "b"
|
|
case c = "c"
|
|
case d = "d"
|
|
case e = "e"
|
|
case f = "f"
|
|
}
|
|
public func encode(to encoder: Encoder) throws {
|
|
var container = encoder.container(keyedBy: CodingKeys.self)
|
|
if a != 0.0 {
|
|
try container.encodeIfPresent(a, forKey: .a)
|
|
}
|
|
var bContainer = container.nestedUnkeyedContainer(forKey: .b)
|
|
for index in b.startIndex..<b.endIndex {
|
|
try bContainer.encode(b[index])
|
|
}
|
|
if c != 0 {
|
|
try container.encodeIfPresent(c, forKey: .c)
|
|
}
|
|
var dContainer = container.nestedUnkeyedContainer(forKey: .d)
|
|
for index in d.startIndex..<d.endIndex {
|
|
try dContainer.encode(d[index])
|
|
}
|
|
if e != 0 {
|
|
try container.encodeIfPresent(e, forKey: .e)
|
|
}
|
|
var fContainer = container.nestedUnkeyedContainer(forKey: .f)
|
|
for index in f.startIndex..<f.endIndex {
|
|
try fContainer.encode(f[index])
|
|
}
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
public struct MyGame_Example_ArrayStruct_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: Float32 { return _accessor.readBuffer(of: Float32.self, at: 0) }
|
|
@discardableResult public func mutate(a: Float32) -> Bool { return _accessor.mutate(a, index: 0) }
|
|
public var b: FlatbufferVector<Int32> { return _accessor.vector(at: 4, count: 15, size: 4) }
|
|
@discardableResult public func mutate(b: Int32, at index: Int32) -> Bool { return _accessor.mutate(b, index: 4 + (index * 4)) }
|
|
public var c: Int8 { return _accessor.readBuffer(of: Int8.self, at: 64) }
|
|
@discardableResult public func mutate(c: Int8) -> Bool { return _accessor.mutate(c, index: 64) }
|
|
public var d: FlatbufferVector<MyGame_Example_NestedStruct_Mutable> { return _accessor.vector(at: 72, count: 2, size: 32) }
|
|
public var e: Int32 { return _accessor.readBuffer(of: Int32.self, at: 136) }
|
|
@discardableResult public func mutate(e: Int32) -> Bool { return _accessor.mutate(e, index: 136) }
|
|
public var f: FlatbufferVector<Int64> { return _accessor.vector(at: 144, count: 2, size: 8) }
|
|
@discardableResult public func mutate(f: Int64, at index: Int32) -> Bool { return _accessor.mutate(f, index: 144 + (index * 8)) }
|
|
|
|
public func unpack() -> MyGame_Example_ArrayStruct {
|
|
return MyGame_Example_ArrayStruct(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ArrayStruct?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ArrayStruct) -> Offset {
|
|
return builder.create(struct: obj)
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
public struct MyGame_Example_ArrayTable: 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 { "ARRT" }
|
|
public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: MyGame_Example_ArrayTable.id, addPrefix: prefix) }
|
|
private init(_ t: Table) { _accessor = t }
|
|
public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
|
|
|
|
private enum VTOFFSET: VOffset {
|
|
case a = 4
|
|
var v: Int32 { Int32(self.rawValue) }
|
|
var p: VOffset { self.rawValue }
|
|
}
|
|
|
|
public var a: MyGame_Example_ArrayStruct? { let o = _accessor.offset(VTOFFSET.a.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Example_ArrayStruct.self, at: o) }
|
|
public var mutableA: MyGame_Example_ArrayStruct_Mutable? { let o = _accessor.offset(VTOFFSET.a.v); return o == 0 ? nil : MyGame_Example_ArrayStruct_Mutable(_accessor.bb, o: o + _accessor.position) }
|
|
public static func startArrayTable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
|
|
public static func add(a: MyGame_Example_ArrayStruct?, _ fbb: inout FlatBufferBuilder) { guard let a = a else { return }; fbb.create(struct: a, position: VTOFFSET.a.p) }
|
|
public static func endArrayTable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
|
|
public static func createArrayTable(
|
|
_ fbb: inout FlatBufferBuilder,
|
|
a: MyGame_Example_ArrayStruct? = nil
|
|
) -> Offset {
|
|
let __start = MyGame_Example_ArrayTable.startArrayTable(&fbb)
|
|
MyGame_Example_ArrayTable.add(a: a, &fbb)
|
|
return MyGame_Example_ArrayTable.endArrayTable(&fbb, start: __start)
|
|
}
|
|
|
|
public func unpack() -> MyGame_Example_ArrayTableT {
|
|
return MyGame_Example_ArrayTableT(self)
|
|
}
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ArrayTableT?) -> Offset {
|
|
guard var obj = obj else { return Offset() }
|
|
return pack(&builder, obj: &obj)
|
|
}
|
|
|
|
public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MyGame_Example_ArrayTableT) -> Offset {
|
|
let __root = MyGame_Example_ArrayTable.startArrayTable(&builder)
|
|
MyGame_Example_ArrayTable.add(a: obj.a, &builder)
|
|
return MyGame_Example_ArrayTable.endArrayTable(&builder, start: __root)
|
|
}
|
|
|
|
public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
|
|
var _v = try verifier.visitTable(at: position)
|
|
try _v.visit(field: VTOFFSET.a.p, fieldName: "a", required: false, type: MyGame_Example_ArrayStruct.self)
|
|
_v.finish()
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
extension MyGame_Example_ArrayTable: 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)
|
|
}
|
|
}
|
|
|
|
@available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
|
|
public class MyGame_Example_ArrayTableT: NativeObject {
|
|
|
|
public var a: MyGame_Example_ArrayStruct?
|
|
|
|
public init(_ _t: borrowing MyGame_Example_ArrayTable) {
|
|
a = _t.a
|
|
}
|
|
|
|
public init() {
|
|
a = MyGame_Example_ArrayStruct()
|
|
}
|
|
|
|
public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_ArrayTable.self) }
|
|
|
|
}
|
|
#endif
|