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

   1 // automatically generated by the FlatBuffers compiler, do not modify
   2 // swiftlint:disable all
   3 // swiftformat:disable all
   4
   5 import FlatBuffers
   6
   7 public enum Character: UInt8, Enum {
   8   public typealias T = UInt8
   9   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
  10   public var value: UInt8 { return self.rawValue }
  11   case none_ = 0
  12   case mulan = 1
  13   case rapunzel = 2
  14   case belle = 3
  15   case bookfan = 4
  16   case other = 5
  17   case unused = 6
  18
  19
  20   public static var max: Character { return .unused }
  21   public static var min: Character { return .none_ }
  22 }
  23
  24 public struct CharacterUnion {
  25   public var type: Character
  26   public var value: NativeObject?
  27   public init(_ v: NativeObject?, type: Character) {
  28     self.type = type
  29     self.value = v
  30   }
  31   public func pack(builder: inout FlatBufferBuilder) -> Offset {
  32     switch type {
  33     case .mulan:
  34       var __obj = value as? AttackerT
  35       return Attacker.pack(&builder, obj: &__obj)
  36     case .rapunzel:
  37       var __obj = value as? Rapunzel
  38       return Rapunzel_Mutable.pack(&builder, obj: &__obj)
  39     case .belle:
  40       var __obj = value as? BookReader
  41       return BookReader_Mutable.pack(&builder, obj: &__obj)
  42     case .bookfan:
  43       var __obj = value as? BookReader
  44       return BookReader_Mutable.pack(&builder, obj: &__obj)
  45     case .other:
  46       var __obj = value as? String
  47       return String.pack(&builder, obj: &__obj)
  48     case .unused:
  49       var __obj = value as? String
  50       return String.pack(&builder, obj: &__obj)
  51     default: return Offset()
  52     }
  53   }
  54 }
  55 public struct Rapunzel: NativeStruct, NativeObject {
  56
  57   static func validateVersion() { FlatBuffersVersion_2_0_0() }
  58
  59   private var _hairLength: Int32
  60
  61   public init(hairLength: Int32) {
  62     _hairLength = hairLength
  63   }
  64
  65   public init() {
  66     _hairLength = 0
  67   }
  68
  69   public init(_ _t: inout Rapunzel_Mutable) {
  70     _hairLength = _t.hairLength
  71   }
  72
  73   public var hairLength: Int32 { _hairLength }
  74 }
  75
  76 public struct Rapunzel_Mutable: FlatBufferObject {
  77
  78   static func validateVersion() { FlatBuffersVersion_2_0_0() }
  79   public var __buffer: ByteBuffer! { return _accessor.bb }
  80   private var _accessor: Struct
  81
  82   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
  83
  84   public var hairLength: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
  85   @discardableResult public func mutate(hairLength: Int32) -> Bool { return _accessor.mutate(hairLength, index: 0) }
  86
  87
  88   public mutating func unpack() -> Rapunzel {
  89     return Rapunzel(&self)
  90   }
  91   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Rapunzel?) -> Offset {
  92     guard var obj = obj else { return Offset() }
  93     return pack(&builder, obj: &obj)
  94   }
  95
  96   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout Rapunzel) -> Offset {
  97     return builder.create(struct: obj)
  98   }
  99 }
 100
 101 public struct BookReader: NativeStruct, NativeObject {
 102
 103   static func validateVersion() { FlatBuffersVersion_2_0_0() }
 104
 105   private var _booksRead: Int32
 106
 107   public init(booksRead: Int32) {
 108     _booksRead = booksRead
 109   }
 110
 111   public init() {
 112     _booksRead = 0
 113   }
 114
 115   public init(_ _t: inout BookReader_Mutable) {
 116     _booksRead = _t.booksRead
 117   }
 118
 119   public var booksRead: Int32 { _booksRead }
 120 }
 121
 122 public struct BookReader_Mutable: FlatBufferObject {
 123
 124   static func validateVersion() { FlatBuffersVersion_2_0_0() }
 125   public var __buffer: ByteBuffer! { return _accessor.bb }
 126   private var _accessor: Struct
 127
 128   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
 129
 130   public var booksRead: Int32 { return _accessor.readBuffer(of: Int32.self, at: 0) }
 131   @discardableResult public func mutate(booksRead: Int32) -> Bool { return _accessor.mutate(booksRead, index: 0) }
 132
 133
 134   public mutating func unpack() -> BookReader {
 135     return BookReader(&self)
 136   }
 137   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReader?) -> Offset {
 138     guard var obj = obj else { return Offset() }
 139     return pack(&builder, obj: &obj)
 140   }
 141
 142   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout BookReader) -> Offset {
 143     return builder.create(struct: obj)
 144   }
 145 }
 146
 147 public struct Attacker: FlatBufferObject, ObjectAPIPacker {
 148
 149   static func validateVersion() { FlatBuffersVersion_2_0_0() }
 150   public var __buffer: ByteBuffer! { return _accessor.bb }
 151   private var _accessor: Table
 152
 153   public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
 154   public static func getRootAsAttacker(bb: ByteBuffer) -> Attacker { return Attacker(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
 155
 156   private init(_ t: Table) { _accessor = t }
 157   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
 158
 159   private enum VTOFFSET: VOffset {
 160     case swordAttackDamage = 4
 161     var v: Int32 { Int32(self.rawValue) }
 162     var p: VOffset { self.rawValue }
 163   }
 164
 165   public var swordAttackDamage: Int32 { let o = _accessor.offset(VTOFFSET.swordAttackDamage.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
 166   @discardableResult public func mutate(swordAttackDamage: Int32) -> Bool {let o = _accessor.offset(VTOFFSET.swordAttackDamage.v);  return _accessor.mutate(swordAttackDamage, index: o) }
 167   public static func startAttacker(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
 168   public static func add(swordAttackDamage: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: swordAttackDamage, def: 0, at: VTOFFSET.swordAttackDamage.p) }
 169   public static func endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
 170   public static func createAttacker(
 171     _ fbb: inout FlatBufferBuilder,
 172     swordAttackDamage: Int32 = 0
 173   ) -> Offset {
 174     let __start = Attacker.startAttacker(&fbb)
 175     Attacker.add(swordAttackDamage: swordAttackDamage, &fbb)
 176     return Attacker.endAttacker(&fbb, start: __start)
 177   }
 178
 179
 180   public mutating func unpack() -> AttackerT {
 181     return AttackerT(&self)
 182   }
 183   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT?) -> Offset {
 184     guard var obj = obj else { return Offset() }
 185     return pack(&builder, obj: &obj)
 186   }
 187
 188   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout AttackerT) -> Offset {
 189     let __root = Attacker.startAttacker(&builder)
 190     Attacker.add(swordAttackDamage: obj.swordAttackDamage, &builder)
 191     return Attacker.endAttacker(&builder, start: __root)
 192   }
 193 }
 194
 195 public class AttackerT: NativeObject {
 196
 197   public var swordAttackDamage: Int32
 198
 199   public init(_ _t: inout Attacker) {
 200     swordAttackDamage = _t.swordAttackDamage
 201   }
 202
 203   public init() {
 204     swordAttackDamage = 0
 205   }
 206
 207   public func serialize() -> ByteBuffer { return serialize(type: Attacker.self) }
 208
 209 }
 210 public struct Movie: FlatBufferObject, ObjectAPIPacker {
 211
 212   static func validateVersion() { FlatBuffersVersion_2_0_0() }
 213   public var __buffer: ByteBuffer! { return _accessor.bb }
 214   private var _accessor: Table
 215
 216   public static func finish(_ fbb: inout FlatBufferBuilder, end: Offset, prefix: Bool = false) { fbb.finish(offset: end, fileId: "MOVI", addPrefix: prefix) }
 217   public static func getRootAsMovie(bb: ByteBuffer) -> Movie { return Movie(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
 218
 219   private init(_ t: Table) { _accessor = t }
 220   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
 221
 222   private enum VTOFFSET: VOffset {
 223     case mainCharacterType = 4
 224     case mainCharacter = 6
 225     case charactersType = 8
 226     case characters = 10
 227     var v: Int32 { Int32(self.rawValue) }
 228     var p: VOffset { self.rawValue }
 229   }
 230
 231   public var mainCharacterType: Character { let o = _accessor.offset(VTOFFSET.mainCharacterType.v); return o == 0 ? .none_ : Character(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
 232   public func mainCharacter<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.mainCharacter.v); return o == 0 ? nil : _accessor.union(o) }
 233   public var charactersTypeCount: Int32 { let o = _accessor.offset(VTOFFSET.charactersType.v); return o == 0 ? 0 : _accessor.vector(count: o) }
 234   public func charactersType(at index: Int32) -> Character? { let o = _accessor.offset(VTOFFSET.charactersType.v); return o == 0 ? Character.none_ : Character(rawValue: _accessor.directRead(of: UInt8.self, offset: _accessor.vector(at: o) + index * 1)) }
 235   public var charactersCount: Int32 { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? 0 : _accessor.vector(count: o) }
 236   public func characters<T: FlatbuffersInitializable>(at index: Int32, type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.characters.v); return o == 0 ? nil : _accessor.directUnion(_accessor.vector(at: o) + index * 4) }
 237   public static func startMovie(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) }
 238   public static func add(mainCharacterType: Character, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mainCharacterType.rawValue, def: 0, at: VTOFFSET.mainCharacterType.p) }
 239   public static func add(mainCharacter: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: mainCharacter, at: VTOFFSET.mainCharacter.p) }
 240   public static func addVectorOf(charactersType: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p) }
 241   public static func addVectorOf(characters: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p) }
 242   public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
 243   public static func createMovie(
 244     _ fbb: inout FlatBufferBuilder,
 245     mainCharacterType: Character = .none_,
 246     mainCharacterOffset mainCharacter: Offset = Offset(),
 247     charactersTypeVectorOffset charactersType: Offset = Offset(),
 248     charactersVectorOffset characters: Offset = Offset()
 249   ) -> Offset {
 250     let __start = Movie.startMovie(&fbb)
 251     Movie.add(mainCharacterType: mainCharacterType, &fbb)
 252     Movie.add(mainCharacter: mainCharacter, &fbb)
 253     Movie.addVectorOf(charactersType: charactersType, &fbb)
 254     Movie.addVectorOf(characters: characters, &fbb)
 255     return Movie.endMovie(&fbb, start: __start)
 256   }
 257
 258
 259   public mutating func unpack() -> MovieT {
 260     return MovieT(&self)
 261   }
 262   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT?) -> Offset {
 263     guard var obj = obj else { return Offset() }
 264     return pack(&builder, obj: &obj)
 265   }
 266
 267   public static func pack(_ builder: inout FlatBufferBuilder, obj: inout MovieT) -> Offset {
 268     let __mainCharacter = obj.mainCharacter?.pack(builder: &builder) ?? Offset()
 269     var __characters__: [Offset] = []
 270     for i in obj.characters {
 271       guard let off = i?.pack(builder: &builder) else { continue }
 272       __characters__.append(off)
 273     }
 274     let __characters = builder.createVector(ofOffsets: __characters__)
 275     let __charactersType = builder.createVector(obj.characters.compactMap { $0?.type })
 276     let __root = Movie.startMovie(&builder)
 277     if let o = obj.mainCharacter?.type {
 278       Movie.add(mainCharacterType: o, &builder)
 279       Movie.add(mainCharacter: __mainCharacter, &builder)
 280     }
 281
 282     Movie.addVectorOf(charactersType: __charactersType, &builder)
 283     Movie.addVectorOf(characters: __characters, &builder)
 284     return Movie.endMovie(&builder, start: __root)
 285   }
 286 }
 287
 288 public class MovieT: NativeObject {
 289
 290   public var mainCharacter: CharacterUnion?
 291   public var characters: [CharacterUnion?]
 292
 293   public init(_ _t: inout Movie) {
 294     switch _t.mainCharacterType {
 295     case .mulan:
 296       var _v = _t.mainCharacter(type: Attacker.self)
 297       mainCharacter = CharacterUnion(_v?.unpack(), type: .mulan)
 298     case .rapunzel:
 299       var _v = _t.mainCharacter(type: Rapunzel_Mutable.self)
 300       mainCharacter = CharacterUnion(_v?.unpack(), type: .rapunzel)
 301     case .belle:
 302       var _v = _t.mainCharacter(type: BookReader_Mutable.self)
 303       mainCharacter = CharacterUnion(_v?.unpack(), type: .belle)
 304     case .bookfan:
 305       var _v = _t.mainCharacter(type: BookReader_Mutable.self)
 306       mainCharacter = CharacterUnion(_v?.unpack(), type: .bookfan)
 307     case .other:
 308       var _v = _t.mainCharacter(type: String.self)
 309       mainCharacter = CharacterUnion(_v?.unpack(), type: .other)
 310     case .unused:
 311       var _v = _t.mainCharacter(type: String.self)
 312       mainCharacter = CharacterUnion(_v?.unpack(), type: .unused)
 313     default: break
 314     }
 315     characters = []
 316     for index in 0..<_t.charactersCount {
 317         switch _t.charactersType(at: index) {
 318         case .mulan:
 319           var _v = _t.characters(at: index, type: Attacker.self)
 320           characters.append(CharacterUnion(_v?.unpack(), type: .mulan))
 321         case .rapunzel:
 322           var _v = _t.characters(at: index, type: Rapunzel_Mutable.self)
 323           characters.append(CharacterUnion(_v?.unpack(), type: .rapunzel))
 324         case .belle:
 325           var _v = _t.characters(at: index, type: BookReader_Mutable.self)
 326           characters.append(CharacterUnion(_v?.unpack(), type: .belle))
 327         case .bookfan:
 328           var _v = _t.characters(at: index, type: BookReader_Mutable.self)
 329           characters.append(CharacterUnion(_v?.unpack(), type: .bookfan))
 330         case .other:
 331           var _v = _t.characters(at: index, type: String.self)
 332           characters.append(CharacterUnion(_v?.unpack(), type: .other))
 333         case .unused:
 334           var _v = _t.characters(at: index, type: String.self)
 335           characters.append(CharacterUnion(_v?.unpack(), type: .unused))
 336         default: break
 337         }
 338     }
 339   }
 340
 341   public init() {
 342     characters = []
 343   }
 344
 345   public func serialize() -> ByteBuffer { return serialize(type: Movie.self) }
 346
 347 }