1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_MOBILEBYTECODE_TORCH_JIT_MOBILE_SERIALIZATION_H_
5 #define FLATBUFFERS_GENERATED_MOBILEBYTECODE_TORCH_JIT_MOBILE_SERIALIZATION_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 23 &&
12 FLATBUFFERS_VERSION_MINOR == 3 &&
13 FLATBUFFERS_VERSION_REVISION == 3,
14 "Non-compatible flatbuffers version included");
15
16 namespace torch {
17 namespace jit {
18 namespace mobile {
19 namespace serialization {
20
21 struct Int;
22
23 struct Bool;
24
25 struct Double;
26
27 struct PerTensorAffineSchema;
28
29 struct QuantizedSchema;
30 struct QuantizedSchemaBuilder;
31
32 struct TensorMetadata;
33 struct TensorMetadataBuilder;
34
35 struct String;
36 struct StringBuilder;
37
38 struct Device;
39 struct DeviceBuilder;
40
41 struct List;
42 struct ListBuilder;
43
44 struct IntList;
45 struct IntListBuilder;
46
47 struct DoubleList;
48 struct DoubleListBuilder;
49
50 struct BoolList;
51 struct BoolListBuilder;
52
53 struct Tuple;
54 struct TupleBuilder;
55
56 struct Dict;
57 struct DictBuilder;
58
59 struct ObjectType;
60 struct ObjectTypeBuilder;
61
62 struct Object;
63 struct ObjectBuilder;
64
65 struct ComplexDouble;
66
67 struct EnumValue;
68 struct EnumValueBuilder;
69
70 struct Instruction;
71
72 struct Operator;
73 struct OperatorBuilder;
74
75 struct Arg;
76 struct ArgBuilder;
77
78 struct Schema;
79 struct SchemaBuilder;
80
81 struct DebugInfo;
82 struct DebugInfoBuilder;
83
84 struct Function;
85 struct FunctionBuilder;
86
87 struct StorageData;
88 struct StorageDataBuilder;
89
90 struct IValue;
91 struct IValueBuilder;
92
93 struct ExtraFile;
94 struct ExtraFileBuilder;
95
96 struct Module;
97 struct ModuleBuilder;
98
99 enum class TypeType : uint8_t {
100 UNSET = 0,
101 CLASS_WITH_FIELD = 1,
102 CUSTOM_CLASS = 2,
103 CLASS_WITH_SETSTATE = 3,
104 NON_OBJ = 4,
105 MIN = UNSET,
106 MAX = NON_OBJ
107 };
108
EnumValuesTypeType()109 inline const TypeType (&EnumValuesTypeType())[5] {
110 static const TypeType values[] = {
111 TypeType::UNSET,
112 TypeType::CLASS_WITH_FIELD,
113 TypeType::CUSTOM_CLASS,
114 TypeType::CLASS_WITH_SETSTATE,
115 TypeType::NON_OBJ
116 };
117 return values;
118 }
119
EnumNamesTypeType()120 inline const char * const *EnumNamesTypeType() {
121 static const char * const names[6] = {
122 "UNSET",
123 "CLASS_WITH_FIELD",
124 "CUSTOM_CLASS",
125 "CLASS_WITH_SETSTATE",
126 "NON_OBJ",
127 nullptr
128 };
129 return names;
130 }
131
EnumNameTypeType(TypeType e)132 inline const char *EnumNameTypeType(TypeType e) {
133 if (::flatbuffers::IsOutRange(e, TypeType::UNSET, TypeType::NON_OBJ)) return "";
134 const size_t index = static_cast<size_t>(e);
135 return EnumNamesTypeType()[index];
136 }
137
138 enum class IValueUnion : uint8_t {
139 NONE = 0,
140 Int = 1,
141 Bool = 2,
142 Double = 3,
143 ComplexDouble = 4,
144 TensorMetadata = 5,
145 String = 6,
146 List = 7,
147 Tuple = 8,
148 Dict = 9,
149 Object = 10,
150 IntList = 11,
151 DoubleList = 12,
152 BoolList = 13,
153 Device = 14,
154 EnumValue = 15,
155 Function = 16,
156 MIN = NONE,
157 MAX = Function
158 };
159
EnumValuesIValueUnion()160 inline const IValueUnion (&EnumValuesIValueUnion())[17] {
161 static const IValueUnion values[] = {
162 IValueUnion::NONE,
163 IValueUnion::Int,
164 IValueUnion::Bool,
165 IValueUnion::Double,
166 IValueUnion::ComplexDouble,
167 IValueUnion::TensorMetadata,
168 IValueUnion::String,
169 IValueUnion::List,
170 IValueUnion::Tuple,
171 IValueUnion::Dict,
172 IValueUnion::Object,
173 IValueUnion::IntList,
174 IValueUnion::DoubleList,
175 IValueUnion::BoolList,
176 IValueUnion::Device,
177 IValueUnion::EnumValue,
178 IValueUnion::Function
179 };
180 return values;
181 }
182
EnumNamesIValueUnion()183 inline const char * const *EnumNamesIValueUnion() {
184 static const char * const names[18] = {
185 "NONE",
186 "Int",
187 "Bool",
188 "Double",
189 "ComplexDouble",
190 "TensorMetadata",
191 "String",
192 "List",
193 "Tuple",
194 "Dict",
195 "Object",
196 "IntList",
197 "DoubleList",
198 "BoolList",
199 "Device",
200 "EnumValue",
201 "Function",
202 nullptr
203 };
204 return names;
205 }
206
EnumNameIValueUnion(IValueUnion e)207 inline const char *EnumNameIValueUnion(IValueUnion e) {
208 if (::flatbuffers::IsOutRange(e, IValueUnion::NONE, IValueUnion::Function)) return "";
209 const size_t index = static_cast<size_t>(e);
210 return EnumNamesIValueUnion()[index];
211 }
212
213 template<typename T> struct IValueUnionTraits {
214 static const IValueUnion enum_value = IValueUnion::NONE;
215 };
216
217 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Int> {
218 static const IValueUnion enum_value = IValueUnion::Int;
219 };
220
221 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Bool> {
222 static const IValueUnion enum_value = IValueUnion::Bool;
223 };
224
225 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Double> {
226 static const IValueUnion enum_value = IValueUnion::Double;
227 };
228
229 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::ComplexDouble> {
230 static const IValueUnion enum_value = IValueUnion::ComplexDouble;
231 };
232
233 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::TensorMetadata> {
234 static const IValueUnion enum_value = IValueUnion::TensorMetadata;
235 };
236
237 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::String> {
238 static const IValueUnion enum_value = IValueUnion::String;
239 };
240
241 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::List> {
242 static const IValueUnion enum_value = IValueUnion::List;
243 };
244
245 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Tuple> {
246 static const IValueUnion enum_value = IValueUnion::Tuple;
247 };
248
249 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Dict> {
250 static const IValueUnion enum_value = IValueUnion::Dict;
251 };
252
253 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Object> {
254 static const IValueUnion enum_value = IValueUnion::Object;
255 };
256
257 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::IntList> {
258 static const IValueUnion enum_value = IValueUnion::IntList;
259 };
260
261 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::DoubleList> {
262 static const IValueUnion enum_value = IValueUnion::DoubleList;
263 };
264
265 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::BoolList> {
266 static const IValueUnion enum_value = IValueUnion::BoolList;
267 };
268
269 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Device> {
270 static const IValueUnion enum_value = IValueUnion::Device;
271 };
272
273 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::EnumValue> {
274 static const IValueUnion enum_value = IValueUnion::EnumValue;
275 };
276
277 template<> struct IValueUnionTraits<torch::jit::mobile::serialization::Function> {
278 static const IValueUnion enum_value = IValueUnion::Function;
279 };
280
281 bool VerifyIValueUnion(::flatbuffers::Verifier &verifier, const void *obj, IValueUnion type);
282 bool VerifyIValueUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<IValueUnion> *types);
283
284 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Int FLATBUFFERS_FINAL_CLASS {
285 private:
286 int64_t int_val_;
287
288 public:
289 Int()
290 : int_val_(0) {
291 }
292 Int(int64_t _int_val)
293 : int_val_(::flatbuffers::EndianScalar(_int_val)) {
294 }
295 int64_t int_val() const {
296 return ::flatbuffers::EndianScalar(int_val_);
297 }
298 void mutate_int_val(int64_t _int_val) {
299 ::flatbuffers::WriteScalar(&int_val_, _int_val);
300 }
301 };
302 FLATBUFFERS_STRUCT_END(Int, 8);
303
304 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(1) Bool FLATBUFFERS_FINAL_CLASS {
305 private:
306 uint8_t bool_val_;
307
308 public:
309 Bool()
310 : bool_val_(0) {
311 }
312 Bool(bool _bool_val)
313 : bool_val_(::flatbuffers::EndianScalar(static_cast<uint8_t>(_bool_val))) {
314 }
315 bool bool_val() const {
316 return ::flatbuffers::EndianScalar(bool_val_) != 0;
317 }
318 void mutate_bool_val(bool _bool_val) {
319 ::flatbuffers::WriteScalar(&bool_val_, static_cast<uint8_t>(_bool_val));
320 }
321 };
322 FLATBUFFERS_STRUCT_END(Bool, 1);
323
324 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Double FLATBUFFERS_FINAL_CLASS {
325 private:
326 double double_val_;
327
328 public:
329 Double()
330 : double_val_(0) {
331 }
332 Double(double _double_val)
333 : double_val_(::flatbuffers::EndianScalar(_double_val)) {
334 }
335 double double_val() const {
336 return ::flatbuffers::EndianScalar(double_val_);
337 }
338 void mutate_double_val(double _double_val) {
339 ::flatbuffers::WriteScalar(&double_val_, _double_val);
340 }
341 };
342 FLATBUFFERS_STRUCT_END(Double, 8);
343
344 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) PerTensorAffineSchema FLATBUFFERS_FINAL_CLASS {
345 private:
346 double q_scale_;
347 int32_t q_zero_point_;
348 int32_t padding0__;
349
350 public:
351 PerTensorAffineSchema()
352 : q_scale_(0),
353 q_zero_point_(0),
354 padding0__(0) {
355 (void)padding0__;
356 }
357 PerTensorAffineSchema(double _q_scale, int32_t _q_zero_point)
358 : q_scale_(::flatbuffers::EndianScalar(_q_scale)),
359 q_zero_point_(::flatbuffers::EndianScalar(_q_zero_point)),
360 padding0__(0) {
361 (void)padding0__;
362 }
363 double q_scale() const {
364 return ::flatbuffers::EndianScalar(q_scale_);
365 }
366 void mutate_q_scale(double _q_scale) {
367 ::flatbuffers::WriteScalar(&q_scale_, _q_scale);
368 }
369 int32_t q_zero_point() const {
370 return ::flatbuffers::EndianScalar(q_zero_point_);
371 }
372 void mutate_q_zero_point(int32_t _q_zero_point) {
373 ::flatbuffers::WriteScalar(&q_zero_point_, _q_zero_point);
374 }
375 };
376 FLATBUFFERS_STRUCT_END(PerTensorAffineSchema, 16);
377
378 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ComplexDouble FLATBUFFERS_FINAL_CLASS {
379 private:
380 double real_;
381 double imag_;
382
383 public:
384 ComplexDouble()
385 : real_(0),
386 imag_(0) {
387 }
388 ComplexDouble(double _real, double _imag)
389 : real_(::flatbuffers::EndianScalar(_real)),
390 imag_(::flatbuffers::EndianScalar(_imag)) {
391 }
392 double real() const {
393 return ::flatbuffers::EndianScalar(real_);
394 }
395 void mutate_real(double _real) {
396 ::flatbuffers::WriteScalar(&real_, _real);
397 }
398 double imag() const {
399 return ::flatbuffers::EndianScalar(imag_);
400 }
401 void mutate_imag(double _imag) {
402 ::flatbuffers::WriteScalar(&imag_, _imag);
403 }
404 };
405 FLATBUFFERS_STRUCT_END(ComplexDouble, 16);
406
407 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Instruction FLATBUFFERS_FINAL_CLASS {
408 private:
409 int8_t op_;
410 int8_t padding0__;
411 uint16_t n_;
412 int32_t x_;
413
414 public:
415 Instruction()
416 : op_(0),
417 padding0__(0),
418 n_(0),
419 x_(0) {
420 (void)padding0__;
421 }
422 Instruction(int8_t _op, uint16_t _n, int32_t _x)
423 : op_(::flatbuffers::EndianScalar(_op)),
424 padding0__(0),
425 n_(::flatbuffers::EndianScalar(_n)),
426 x_(::flatbuffers::EndianScalar(_x)) {
427 (void)padding0__;
428 }
429 int8_t op() const {
430 return ::flatbuffers::EndianScalar(op_);
431 }
432 void mutate_op(int8_t _op) {
433 ::flatbuffers::WriteScalar(&op_, _op);
434 }
435 uint16_t n() const {
436 return ::flatbuffers::EndianScalar(n_);
437 }
438 void mutate_n(uint16_t _n) {
439 ::flatbuffers::WriteScalar(&n_, _n);
440 }
441 int32_t x() const {
442 return ::flatbuffers::EndianScalar(x_);
443 }
444 void mutate_x(int32_t _x) {
445 ::flatbuffers::WriteScalar(&x_, _x);
446 }
447 };
448 FLATBUFFERS_STRUCT_END(Instruction, 8);
449
450 struct QuantizedSchema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
451 typedef QuantizedSchemaBuilder Builder;
452 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
453 VT_QSCHEME = 4,
454 VT_SCALE = 6,
455 VT_ZERO_POINT = 8,
456 VT_SCALES = 10,
457 VT_ZERO_POINTS = 12,
458 VT_AXIS = 14
459 };
460 int8_t qscheme() const {
461 return GetField<int8_t>(VT_QSCHEME, 0);
462 }
463 bool mutate_qscheme(int8_t _qscheme = 0) {
464 return SetField<int8_t>(VT_QSCHEME, _qscheme, 0);
465 }
466 double scale() const {
467 return GetField<double>(VT_SCALE, 0.0);
468 }
469 bool mutate_scale(double _scale = 0.0) {
470 return SetField<double>(VT_SCALE, _scale, 0.0);
471 }
472 int32_t zero_point() const {
473 return GetField<int32_t>(VT_ZERO_POINT, 0);
474 }
475 bool mutate_zero_point(int32_t _zero_point = 0) {
476 return SetField<int32_t>(VT_ZERO_POINT, _zero_point, 0);
477 }
478 const torch::jit::mobile::serialization::TensorMetadata *scales() const {
479 return GetPointer<const torch::jit::mobile::serialization::TensorMetadata *>(VT_SCALES);
480 }
481 torch::jit::mobile::serialization::TensorMetadata *mutable_scales() {
482 return GetPointer<torch::jit::mobile::serialization::TensorMetadata *>(VT_SCALES);
483 }
484 const torch::jit::mobile::serialization::TensorMetadata *zero_points() const {
485 return GetPointer<const torch::jit::mobile::serialization::TensorMetadata *>(VT_ZERO_POINTS);
486 }
487 torch::jit::mobile::serialization::TensorMetadata *mutable_zero_points() {
488 return GetPointer<torch::jit::mobile::serialization::TensorMetadata *>(VT_ZERO_POINTS);
489 }
490 int32_t axis() const {
491 return GetField<int32_t>(VT_AXIS, 0);
492 }
493 bool mutate_axis(int32_t _axis = 0) {
494 return SetField<int32_t>(VT_AXIS, _axis, 0);
495 }
496 bool Verify(::flatbuffers::Verifier &verifier) const {
497 return VerifyTableStart(verifier) &&
498 VerifyField<int8_t>(verifier, VT_QSCHEME, 1) &&
499 VerifyField<double>(verifier, VT_SCALE, 8) &&
500 VerifyField<int32_t>(verifier, VT_ZERO_POINT, 4) &&
501 VerifyOffset(verifier, VT_SCALES) &&
502 verifier.VerifyTable(scales()) &&
503 VerifyOffset(verifier, VT_ZERO_POINTS) &&
504 verifier.VerifyTable(zero_points()) &&
505 VerifyField<int32_t>(verifier, VT_AXIS, 4) &&
506 verifier.EndTable();
507 }
508 };
509
510 struct QuantizedSchemaBuilder {
511 typedef QuantizedSchema Table;
512 ::flatbuffers::FlatBufferBuilder &fbb_;
513 ::flatbuffers::uoffset_t start_;
514 void add_qscheme(int8_t qscheme) {
515 fbb_.AddElement<int8_t>(QuantizedSchema::VT_QSCHEME, qscheme, 0);
516 }
517 void add_scale(double scale) {
518 fbb_.AddElement<double>(QuantizedSchema::VT_SCALE, scale, 0.0);
519 }
520 void add_zero_point(int32_t zero_point) {
521 fbb_.AddElement<int32_t>(QuantizedSchema::VT_ZERO_POINT, zero_point, 0);
522 }
523 void add_scales(::flatbuffers::Offset<torch::jit::mobile::serialization::TensorMetadata> scales) {
524 fbb_.AddOffset(QuantizedSchema::VT_SCALES, scales);
525 }
526 void add_zero_points(::flatbuffers::Offset<torch::jit::mobile::serialization::TensorMetadata> zero_points) {
527 fbb_.AddOffset(QuantizedSchema::VT_ZERO_POINTS, zero_points);
528 }
529 void add_axis(int32_t axis) {
530 fbb_.AddElement<int32_t>(QuantizedSchema::VT_AXIS, axis, 0);
531 }
532 explicit QuantizedSchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
533 : fbb_(_fbb) {
534 start_ = fbb_.StartTable();
535 }
536 ::flatbuffers::Offset<QuantizedSchema> Finish() {
537 const auto end = fbb_.EndTable(start_);
538 auto o = ::flatbuffers::Offset<QuantizedSchema>(end);
539 return o;
540 }
541 };
542
543 inline ::flatbuffers::Offset<QuantizedSchema> CreateQuantizedSchema(
544 ::flatbuffers::FlatBufferBuilder &_fbb,
545 int8_t qscheme = 0,
546 double scale = 0.0,
547 int32_t zero_point = 0,
548 ::flatbuffers::Offset<torch::jit::mobile::serialization::TensorMetadata> scales = 0,
549 ::flatbuffers::Offset<torch::jit::mobile::serialization::TensorMetadata> zero_points = 0,
550 int32_t axis = 0) {
551 QuantizedSchemaBuilder builder_(_fbb);
552 builder_.add_scale(scale);
553 builder_.add_axis(axis);
554 builder_.add_zero_points(zero_points);
555 builder_.add_scales(scales);
556 builder_.add_zero_point(zero_point);
557 builder_.add_qscheme(qscheme);
558 return builder_.Finish();
559 }
560
561 struct TensorMetadata FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
562 typedef TensorMetadataBuilder Builder;
563 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
564 VT_STORAGE_LOCATION_INDEX = 4,
565 VT_SCALAR_TYPE = 6,
566 VT_STORAGE_OFFSET = 8,
567 VT_SIZES = 10,
568 VT_STRIDES = 12,
569 VT_REQUIRES_GRAD = 14,
570 VT_QUANTIZED_SCHEMA = 16
571 };
572 uint32_t storage_location_index() const {
573 return GetField<uint32_t>(VT_STORAGE_LOCATION_INDEX, 0);
574 }
575 bool mutate_storage_location_index(uint32_t _storage_location_index = 0) {
576 return SetField<uint32_t>(VT_STORAGE_LOCATION_INDEX, _storage_location_index, 0);
577 }
578 int8_t scalar_type() const {
579 return GetField<int8_t>(VT_SCALAR_TYPE, 0);
580 }
581 bool mutate_scalar_type(int8_t _scalar_type = 0) {
582 return SetField<int8_t>(VT_SCALAR_TYPE, _scalar_type, 0);
583 }
584 int32_t storage_offset() const {
585 return GetField<int32_t>(VT_STORAGE_OFFSET, 0);
586 }
587 bool mutate_storage_offset(int32_t _storage_offset = 0) {
588 return SetField<int32_t>(VT_STORAGE_OFFSET, _storage_offset, 0);
589 }
590 const ::flatbuffers::Vector<int32_t> *sizes() const {
591 return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SIZES);
592 }
593 ::flatbuffers::Vector<int32_t> *mutable_sizes() {
594 return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_SIZES);
595 }
596 const ::flatbuffers::Vector<int32_t> *strides() const {
597 return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_STRIDES);
598 }
599 ::flatbuffers::Vector<int32_t> *mutable_strides() {
600 return GetPointer<::flatbuffers::Vector<int32_t> *>(VT_STRIDES);
601 }
602 bool requires_grad() const {
603 return GetField<uint8_t>(VT_REQUIRES_GRAD, 0) != 0;
604 }
605 bool mutate_requires_grad(bool _requires_grad = 0) {
606 return SetField<uint8_t>(VT_REQUIRES_GRAD, static_cast<uint8_t>(_requires_grad), 0);
607 }
608 const torch::jit::mobile::serialization::QuantizedSchema *quantized_schema() const {
609 return GetPointer<const torch::jit::mobile::serialization::QuantizedSchema *>(VT_QUANTIZED_SCHEMA);
610 }
611 torch::jit::mobile::serialization::QuantizedSchema *mutable_quantized_schema() {
612 return GetPointer<torch::jit::mobile::serialization::QuantizedSchema *>(VT_QUANTIZED_SCHEMA);
613 }
614 bool Verify(::flatbuffers::Verifier &verifier) const {
615 return VerifyTableStart(verifier) &&
616 VerifyField<uint32_t>(verifier, VT_STORAGE_LOCATION_INDEX, 4) &&
617 VerifyField<int8_t>(verifier, VT_SCALAR_TYPE, 1) &&
618 VerifyField<int32_t>(verifier, VT_STORAGE_OFFSET, 4) &&
619 VerifyOffset(verifier, VT_SIZES) &&
620 verifier.VerifyVector(sizes()) &&
621 VerifyOffset(verifier, VT_STRIDES) &&
622 verifier.VerifyVector(strides()) &&
623 VerifyField<uint8_t>(verifier, VT_REQUIRES_GRAD, 1) &&
624 VerifyOffset(verifier, VT_QUANTIZED_SCHEMA) &&
625 verifier.VerifyTable(quantized_schema()) &&
626 verifier.EndTable();
627 }
628 };
629
630 struct TensorMetadataBuilder {
631 typedef TensorMetadata Table;
632 ::flatbuffers::FlatBufferBuilder &fbb_;
633 ::flatbuffers::uoffset_t start_;
634 void add_storage_location_index(uint32_t storage_location_index) {
635 fbb_.AddElement<uint32_t>(TensorMetadata::VT_STORAGE_LOCATION_INDEX, storage_location_index, 0);
636 }
637 void add_scalar_type(int8_t scalar_type) {
638 fbb_.AddElement<int8_t>(TensorMetadata::VT_SCALAR_TYPE, scalar_type, 0);
639 }
640 void add_storage_offset(int32_t storage_offset) {
641 fbb_.AddElement<int32_t>(TensorMetadata::VT_STORAGE_OFFSET, storage_offset, 0);
642 }
643 void add_sizes(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> sizes) {
644 fbb_.AddOffset(TensorMetadata::VT_SIZES, sizes);
645 }
646 void add_strides(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> strides) {
647 fbb_.AddOffset(TensorMetadata::VT_STRIDES, strides);
648 }
649 void add_requires_grad(bool requires_grad) {
650 fbb_.AddElement<uint8_t>(TensorMetadata::VT_REQUIRES_GRAD, static_cast<uint8_t>(requires_grad), 0);
651 }
652 void add_quantized_schema(::flatbuffers::Offset<torch::jit::mobile::serialization::QuantizedSchema> quantized_schema) {
653 fbb_.AddOffset(TensorMetadata::VT_QUANTIZED_SCHEMA, quantized_schema);
654 }
655 explicit TensorMetadataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
656 : fbb_(_fbb) {
657 start_ = fbb_.StartTable();
658 }
659 ::flatbuffers::Offset<TensorMetadata> Finish() {
660 const auto end = fbb_.EndTable(start_);
661 auto o = ::flatbuffers::Offset<TensorMetadata>(end);
662 return o;
663 }
664 };
665
666 inline ::flatbuffers::Offset<TensorMetadata> CreateTensorMetadata(
667 ::flatbuffers::FlatBufferBuilder &_fbb,
668 uint32_t storage_location_index = 0,
669 int8_t scalar_type = 0,
670 int32_t storage_offset = 0,
671 ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> sizes = 0,
672 ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> strides = 0,
673 bool requires_grad = false,
674 ::flatbuffers::Offset<torch::jit::mobile::serialization::QuantizedSchema> quantized_schema = 0) {
675 TensorMetadataBuilder builder_(_fbb);
676 builder_.add_quantized_schema(quantized_schema);
677 builder_.add_strides(strides);
678 builder_.add_sizes(sizes);
679 builder_.add_storage_offset(storage_offset);
680 builder_.add_storage_location_index(storage_location_index);
681 builder_.add_requires_grad(requires_grad);
682 builder_.add_scalar_type(scalar_type);
683 return builder_.Finish();
684 }
685
686 inline ::flatbuffers::Offset<TensorMetadata> CreateTensorMetadataDirect(
687 ::flatbuffers::FlatBufferBuilder &_fbb,
688 uint32_t storage_location_index = 0,
689 int8_t scalar_type = 0,
690 int32_t storage_offset = 0,
691 const std::vector<int32_t> *sizes = nullptr,
692 const std::vector<int32_t> *strides = nullptr,
693 bool requires_grad = false,
694 ::flatbuffers::Offset<torch::jit::mobile::serialization::QuantizedSchema> quantized_schema = 0) {
695 auto sizes__ = sizes ? _fbb.CreateVector<int32_t>(*sizes) : 0;
696 auto strides__ = strides ? _fbb.CreateVector<int32_t>(*strides) : 0;
697 return torch::jit::mobile::serialization::CreateTensorMetadata(
698 _fbb,
699 storage_location_index,
700 scalar_type,
701 storage_offset,
702 sizes__,
703 strides__,
704 requires_grad,
705 quantized_schema);
706 }
707
708 struct String FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
709 typedef StringBuilder Builder;
710 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
711 VT_DATA = 4
712 };
713 const ::flatbuffers::String *data() const {
714 return GetPointer<const ::flatbuffers::String *>(VT_DATA);
715 }
716 ::flatbuffers::String *mutable_data() {
717 return GetPointer<::flatbuffers::String *>(VT_DATA);
718 }
719 bool Verify(::flatbuffers::Verifier &verifier) const {
720 return VerifyTableStart(verifier) &&
721 VerifyOffset(verifier, VT_DATA) &&
722 verifier.VerifyString(data()) &&
723 verifier.EndTable();
724 }
725 };
726
727 struct StringBuilder {
728 typedef String Table;
729 ::flatbuffers::FlatBufferBuilder &fbb_;
730 ::flatbuffers::uoffset_t start_;
731 void add_data(::flatbuffers::Offset<::flatbuffers::String> data) {
732 fbb_.AddOffset(String::VT_DATA, data);
733 }
734 explicit StringBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
735 : fbb_(_fbb) {
736 start_ = fbb_.StartTable();
737 }
738 ::flatbuffers::Offset<String> Finish() {
739 const auto end = fbb_.EndTable(start_);
740 auto o = ::flatbuffers::Offset<String>(end);
741 return o;
742 }
743 };
744
745 inline ::flatbuffers::Offset<String> CreateString(
746 ::flatbuffers::FlatBufferBuilder &_fbb,
747 ::flatbuffers::Offset<::flatbuffers::String> data = 0) {
748 StringBuilder builder_(_fbb);
749 builder_.add_data(data);
750 return builder_.Finish();
751 }
752
753 inline ::flatbuffers::Offset<String> CreateStringDirect(
754 ::flatbuffers::FlatBufferBuilder &_fbb,
755 const char *data = nullptr) {
756 auto data__ = data ? _fbb.CreateString(data) : 0;
757 return torch::jit::mobile::serialization::CreateString(
758 _fbb,
759 data__);
760 }
761
762 struct Device FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
763 typedef DeviceBuilder Builder;
764 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
765 VT_STR = 4
766 };
767 const ::flatbuffers::String *str() const {
768 return GetPointer<const ::flatbuffers::String *>(VT_STR);
769 }
770 ::flatbuffers::String *mutable_str() {
771 return GetPointer<::flatbuffers::String *>(VT_STR);
772 }
773 bool Verify(::flatbuffers::Verifier &verifier) const {
774 return VerifyTableStart(verifier) &&
775 VerifyOffset(verifier, VT_STR) &&
776 verifier.VerifyString(str()) &&
777 verifier.EndTable();
778 }
779 };
780
781 struct DeviceBuilder {
782 typedef Device Table;
783 ::flatbuffers::FlatBufferBuilder &fbb_;
784 ::flatbuffers::uoffset_t start_;
785 void add_str(::flatbuffers::Offset<::flatbuffers::String> str) {
786 fbb_.AddOffset(Device::VT_STR, str);
787 }
788 explicit DeviceBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
789 : fbb_(_fbb) {
790 start_ = fbb_.StartTable();
791 }
792 ::flatbuffers::Offset<Device> Finish() {
793 const auto end = fbb_.EndTable(start_);
794 auto o = ::flatbuffers::Offset<Device>(end);
795 return o;
796 }
797 };
798
799 inline ::flatbuffers::Offset<Device> CreateDevice(
800 ::flatbuffers::FlatBufferBuilder &_fbb,
801 ::flatbuffers::Offset<::flatbuffers::String> str = 0) {
802 DeviceBuilder builder_(_fbb);
803 builder_.add_str(str);
804 return builder_.Finish();
805 }
806
807 inline ::flatbuffers::Offset<Device> CreateDeviceDirect(
808 ::flatbuffers::FlatBufferBuilder &_fbb,
809 const char *str = nullptr) {
810 auto str__ = str ? _fbb.CreateString(str) : 0;
811 return torch::jit::mobile::serialization::CreateDevice(
812 _fbb,
813 str__);
814 }
815
816 struct List FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
817 typedef ListBuilder Builder;
818 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
819 VT_ITEMS = 4,
820 VT_ANNOTATION_STR = 6
821 };
822 const ::flatbuffers::Vector<uint32_t> *items() const {
823 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_ITEMS);
824 }
825 ::flatbuffers::Vector<uint32_t> *mutable_items() {
826 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_ITEMS);
827 }
828 const ::flatbuffers::String *annotation_str() const {
829 return GetPointer<const ::flatbuffers::String *>(VT_ANNOTATION_STR);
830 }
831 ::flatbuffers::String *mutable_annotation_str() {
832 return GetPointer<::flatbuffers::String *>(VT_ANNOTATION_STR);
833 }
834 bool Verify(::flatbuffers::Verifier &verifier) const {
835 return VerifyTableStart(verifier) &&
836 VerifyOffset(verifier, VT_ITEMS) &&
837 verifier.VerifyVector(items()) &&
838 VerifyOffset(verifier, VT_ANNOTATION_STR) &&
839 verifier.VerifyString(annotation_str()) &&
840 verifier.EndTable();
841 }
842 };
843
844 struct ListBuilder {
845 typedef List Table;
846 ::flatbuffers::FlatBufferBuilder &fbb_;
847 ::flatbuffers::uoffset_t start_;
848 void add_items(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> items) {
849 fbb_.AddOffset(List::VT_ITEMS, items);
850 }
851 void add_annotation_str(::flatbuffers::Offset<::flatbuffers::String> annotation_str) {
852 fbb_.AddOffset(List::VT_ANNOTATION_STR, annotation_str);
853 }
854 explicit ListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
855 : fbb_(_fbb) {
856 start_ = fbb_.StartTable();
857 }
858 ::flatbuffers::Offset<List> Finish() {
859 const auto end = fbb_.EndTable(start_);
860 auto o = ::flatbuffers::Offset<List>(end);
861 return o;
862 }
863 };
864
865 inline ::flatbuffers::Offset<List> CreateList(
866 ::flatbuffers::FlatBufferBuilder &_fbb,
867 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> items = 0,
868 ::flatbuffers::Offset<::flatbuffers::String> annotation_str = 0) {
869 ListBuilder builder_(_fbb);
870 builder_.add_annotation_str(annotation_str);
871 builder_.add_items(items);
872 return builder_.Finish();
873 }
874
875 inline ::flatbuffers::Offset<List> CreateListDirect(
876 ::flatbuffers::FlatBufferBuilder &_fbb,
877 const std::vector<uint32_t> *items = nullptr,
878 const char *annotation_str = nullptr) {
879 auto items__ = items ? _fbb.CreateVector<uint32_t>(*items) : 0;
880 auto annotation_str__ = annotation_str ? _fbb.CreateString(annotation_str) : 0;
881 return torch::jit::mobile::serialization::CreateList(
882 _fbb,
883 items__,
884 annotation_str__);
885 }
886
887 struct IntList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
888 typedef IntListBuilder Builder;
889 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
890 VT_ITEMS = 4
891 };
892 const ::flatbuffers::Vector<int64_t> *items() const {
893 return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_ITEMS);
894 }
895 ::flatbuffers::Vector<int64_t> *mutable_items() {
896 return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_ITEMS);
897 }
898 bool Verify(::flatbuffers::Verifier &verifier) const {
899 return VerifyTableStart(verifier) &&
900 VerifyOffset(verifier, VT_ITEMS) &&
901 verifier.VerifyVector(items()) &&
902 verifier.EndTable();
903 }
904 };
905
906 struct IntListBuilder {
907 typedef IntList Table;
908 ::flatbuffers::FlatBufferBuilder &fbb_;
909 ::flatbuffers::uoffset_t start_;
910 void add_items(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> items) {
911 fbb_.AddOffset(IntList::VT_ITEMS, items);
912 }
913 explicit IntListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
914 : fbb_(_fbb) {
915 start_ = fbb_.StartTable();
916 }
917 ::flatbuffers::Offset<IntList> Finish() {
918 const auto end = fbb_.EndTable(start_);
919 auto o = ::flatbuffers::Offset<IntList>(end);
920 return o;
921 }
922 };
923
924 inline ::flatbuffers::Offset<IntList> CreateIntList(
925 ::flatbuffers::FlatBufferBuilder &_fbb,
926 ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> items = 0) {
927 IntListBuilder builder_(_fbb);
928 builder_.add_items(items);
929 return builder_.Finish();
930 }
931
932 inline ::flatbuffers::Offset<IntList> CreateIntListDirect(
933 ::flatbuffers::FlatBufferBuilder &_fbb,
934 const std::vector<int64_t> *items = nullptr) {
935 auto items__ = items ? _fbb.CreateVector<int64_t>(*items) : 0;
936 return torch::jit::mobile::serialization::CreateIntList(
937 _fbb,
938 items__);
939 }
940
941 struct DoubleList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
942 typedef DoubleListBuilder Builder;
943 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
944 VT_ITEMS = 4
945 };
946 const ::flatbuffers::Vector<double> *items() const {
947 return GetPointer<const ::flatbuffers::Vector<double> *>(VT_ITEMS);
948 }
949 ::flatbuffers::Vector<double> *mutable_items() {
950 return GetPointer<::flatbuffers::Vector<double> *>(VT_ITEMS);
951 }
952 bool Verify(::flatbuffers::Verifier &verifier) const {
953 return VerifyTableStart(verifier) &&
954 VerifyOffset(verifier, VT_ITEMS) &&
955 verifier.VerifyVector(items()) &&
956 verifier.EndTable();
957 }
958 };
959
960 struct DoubleListBuilder {
961 typedef DoubleList Table;
962 ::flatbuffers::FlatBufferBuilder &fbb_;
963 ::flatbuffers::uoffset_t start_;
964 void add_items(::flatbuffers::Offset<::flatbuffers::Vector<double>> items) {
965 fbb_.AddOffset(DoubleList::VT_ITEMS, items);
966 }
967 explicit DoubleListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
968 : fbb_(_fbb) {
969 start_ = fbb_.StartTable();
970 }
971 ::flatbuffers::Offset<DoubleList> Finish() {
972 const auto end = fbb_.EndTable(start_);
973 auto o = ::flatbuffers::Offset<DoubleList>(end);
974 return o;
975 }
976 };
977
978 inline ::flatbuffers::Offset<DoubleList> CreateDoubleList(
979 ::flatbuffers::FlatBufferBuilder &_fbb,
980 ::flatbuffers::Offset<::flatbuffers::Vector<double>> items = 0) {
981 DoubleListBuilder builder_(_fbb);
982 builder_.add_items(items);
983 return builder_.Finish();
984 }
985
986 inline ::flatbuffers::Offset<DoubleList> CreateDoubleListDirect(
987 ::flatbuffers::FlatBufferBuilder &_fbb,
988 const std::vector<double> *items = nullptr) {
989 auto items__ = items ? _fbb.CreateVector<double>(*items) : 0;
990 return torch::jit::mobile::serialization::CreateDoubleList(
991 _fbb,
992 items__);
993 }
994
995 struct BoolList FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
996 typedef BoolListBuilder Builder;
997 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
998 VT_ITEMS = 4
999 };
1000 const ::flatbuffers::Vector<uint8_t> *items() const {
1001 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_ITEMS);
1002 }
1003 ::flatbuffers::Vector<uint8_t> *mutable_items() {
1004 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_ITEMS);
1005 }
1006 bool Verify(::flatbuffers::Verifier &verifier) const {
1007 return VerifyTableStart(verifier) &&
1008 VerifyOffset(verifier, VT_ITEMS) &&
1009 verifier.VerifyVector(items()) &&
1010 verifier.EndTable();
1011 }
1012 };
1013
1014 struct BoolListBuilder {
1015 typedef BoolList Table;
1016 ::flatbuffers::FlatBufferBuilder &fbb_;
1017 ::flatbuffers::uoffset_t start_;
1018 void add_items(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> items) {
1019 fbb_.AddOffset(BoolList::VT_ITEMS, items);
1020 }
1021 explicit BoolListBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1022 : fbb_(_fbb) {
1023 start_ = fbb_.StartTable();
1024 }
1025 ::flatbuffers::Offset<BoolList> Finish() {
1026 const auto end = fbb_.EndTable(start_);
1027 auto o = ::flatbuffers::Offset<BoolList>(end);
1028 return o;
1029 }
1030 };
1031
1032 inline ::flatbuffers::Offset<BoolList> CreateBoolList(
1033 ::flatbuffers::FlatBufferBuilder &_fbb,
1034 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> items = 0) {
1035 BoolListBuilder builder_(_fbb);
1036 builder_.add_items(items);
1037 return builder_.Finish();
1038 }
1039
1040 inline ::flatbuffers::Offset<BoolList> CreateBoolListDirect(
1041 ::flatbuffers::FlatBufferBuilder &_fbb,
1042 const std::vector<uint8_t> *items = nullptr) {
1043 auto items__ = items ? _fbb.CreateVector<uint8_t>(*items) : 0;
1044 return torch::jit::mobile::serialization::CreateBoolList(
1045 _fbb,
1046 items__);
1047 }
1048
1049 struct Tuple FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1050 typedef TupleBuilder Builder;
1051 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1052 VT_ITEMS = 4
1053 };
1054 const ::flatbuffers::Vector<uint32_t> *items() const {
1055 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_ITEMS);
1056 }
1057 ::flatbuffers::Vector<uint32_t> *mutable_items() {
1058 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_ITEMS);
1059 }
1060 bool Verify(::flatbuffers::Verifier &verifier) const {
1061 return VerifyTableStart(verifier) &&
1062 VerifyOffset(verifier, VT_ITEMS) &&
1063 verifier.VerifyVector(items()) &&
1064 verifier.EndTable();
1065 }
1066 };
1067
1068 struct TupleBuilder {
1069 typedef Tuple Table;
1070 ::flatbuffers::FlatBufferBuilder &fbb_;
1071 ::flatbuffers::uoffset_t start_;
1072 void add_items(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> items) {
1073 fbb_.AddOffset(Tuple::VT_ITEMS, items);
1074 }
1075 explicit TupleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1076 : fbb_(_fbb) {
1077 start_ = fbb_.StartTable();
1078 }
1079 ::flatbuffers::Offset<Tuple> Finish() {
1080 const auto end = fbb_.EndTable(start_);
1081 auto o = ::flatbuffers::Offset<Tuple>(end);
1082 return o;
1083 }
1084 };
1085
1086 inline ::flatbuffers::Offset<Tuple> CreateTuple(
1087 ::flatbuffers::FlatBufferBuilder &_fbb,
1088 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> items = 0) {
1089 TupleBuilder builder_(_fbb);
1090 builder_.add_items(items);
1091 return builder_.Finish();
1092 }
1093
1094 inline ::flatbuffers::Offset<Tuple> CreateTupleDirect(
1095 ::flatbuffers::FlatBufferBuilder &_fbb,
1096 const std::vector<uint32_t> *items = nullptr) {
1097 auto items__ = items ? _fbb.CreateVector<uint32_t>(*items) : 0;
1098 return torch::jit::mobile::serialization::CreateTuple(
1099 _fbb,
1100 items__);
1101 }
1102
1103 struct Dict FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1104 typedef DictBuilder Builder;
1105 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1106 VT_KEYS = 4,
1107 VT_VALUES = 6,
1108 VT_ANNOTATION_STR = 8
1109 };
1110 const ::flatbuffers::Vector<uint32_t> *keys() const {
1111 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_KEYS);
1112 }
1113 ::flatbuffers::Vector<uint32_t> *mutable_keys() {
1114 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_KEYS);
1115 }
1116 const ::flatbuffers::Vector<uint32_t> *values() const {
1117 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_VALUES);
1118 }
1119 ::flatbuffers::Vector<uint32_t> *mutable_values() {
1120 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_VALUES);
1121 }
1122 const ::flatbuffers::String *annotation_str() const {
1123 return GetPointer<const ::flatbuffers::String *>(VT_ANNOTATION_STR);
1124 }
1125 ::flatbuffers::String *mutable_annotation_str() {
1126 return GetPointer<::flatbuffers::String *>(VT_ANNOTATION_STR);
1127 }
1128 bool Verify(::flatbuffers::Verifier &verifier) const {
1129 return VerifyTableStart(verifier) &&
1130 VerifyOffset(verifier, VT_KEYS) &&
1131 verifier.VerifyVector(keys()) &&
1132 VerifyOffset(verifier, VT_VALUES) &&
1133 verifier.VerifyVector(values()) &&
1134 VerifyOffset(verifier, VT_ANNOTATION_STR) &&
1135 verifier.VerifyString(annotation_str()) &&
1136 verifier.EndTable();
1137 }
1138 };
1139
1140 struct DictBuilder {
1141 typedef Dict Table;
1142 ::flatbuffers::FlatBufferBuilder &fbb_;
1143 ::flatbuffers::uoffset_t start_;
1144 void add_keys(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> keys) {
1145 fbb_.AddOffset(Dict::VT_KEYS, keys);
1146 }
1147 void add_values(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> values) {
1148 fbb_.AddOffset(Dict::VT_VALUES, values);
1149 }
1150 void add_annotation_str(::flatbuffers::Offset<::flatbuffers::String> annotation_str) {
1151 fbb_.AddOffset(Dict::VT_ANNOTATION_STR, annotation_str);
1152 }
1153 explicit DictBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1154 : fbb_(_fbb) {
1155 start_ = fbb_.StartTable();
1156 }
1157 ::flatbuffers::Offset<Dict> Finish() {
1158 const auto end = fbb_.EndTable(start_);
1159 auto o = ::flatbuffers::Offset<Dict>(end);
1160 return o;
1161 }
1162 };
1163
1164 inline ::flatbuffers::Offset<Dict> CreateDict(
1165 ::flatbuffers::FlatBufferBuilder &_fbb,
1166 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> keys = 0,
1167 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> values = 0,
1168 ::flatbuffers::Offset<::flatbuffers::String> annotation_str = 0) {
1169 DictBuilder builder_(_fbb);
1170 builder_.add_annotation_str(annotation_str);
1171 builder_.add_values(values);
1172 builder_.add_keys(keys);
1173 return builder_.Finish();
1174 }
1175
1176 inline ::flatbuffers::Offset<Dict> CreateDictDirect(
1177 ::flatbuffers::FlatBufferBuilder &_fbb,
1178 const std::vector<uint32_t> *keys = nullptr,
1179 const std::vector<uint32_t> *values = nullptr,
1180 const char *annotation_str = nullptr) {
1181 auto keys__ = keys ? _fbb.CreateVector<uint32_t>(*keys) : 0;
1182 auto values__ = values ? _fbb.CreateVector<uint32_t>(*values) : 0;
1183 auto annotation_str__ = annotation_str ? _fbb.CreateString(annotation_str) : 0;
1184 return torch::jit::mobile::serialization::CreateDict(
1185 _fbb,
1186 keys__,
1187 values__,
1188 annotation_str__);
1189 }
1190
1191 struct ObjectType FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1192 typedef ObjectTypeBuilder Builder;
1193 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1194 VT_TYPE_NAME = 4,
1195 VT_TYPE = 6,
1196 VT_ATTR_NAMES = 8
1197 };
1198 const ::flatbuffers::String *type_name() const {
1199 return GetPointer<const ::flatbuffers::String *>(VT_TYPE_NAME);
1200 }
1201 ::flatbuffers::String *mutable_type_name() {
1202 return GetPointer<::flatbuffers::String *>(VT_TYPE_NAME);
1203 }
1204 torch::jit::mobile::serialization::TypeType type() const {
1205 return static_cast<torch::jit::mobile::serialization::TypeType>(GetField<uint8_t>(VT_TYPE, 0));
1206 }
1207 bool mutate_type(torch::jit::mobile::serialization::TypeType _type = static_cast<torch::jit::mobile::serialization::TypeType>(0)) {
1208 return SetField<uint8_t>(VT_TYPE, static_cast<uint8_t>(_type), 0);
1209 }
1210 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *attr_names() const {
1211 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_ATTR_NAMES);
1212 }
1213 ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_attr_names() {
1214 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_ATTR_NAMES);
1215 }
1216 bool Verify(::flatbuffers::Verifier &verifier) const {
1217 return VerifyTableStart(verifier) &&
1218 VerifyOffset(verifier, VT_TYPE_NAME) &&
1219 verifier.VerifyString(type_name()) &&
1220 VerifyField<uint8_t>(verifier, VT_TYPE, 1) &&
1221 VerifyOffset(verifier, VT_ATTR_NAMES) &&
1222 verifier.VerifyVector(attr_names()) &&
1223 verifier.VerifyVectorOfStrings(attr_names()) &&
1224 verifier.EndTable();
1225 }
1226 };
1227
1228 struct ObjectTypeBuilder {
1229 typedef ObjectType Table;
1230 ::flatbuffers::FlatBufferBuilder &fbb_;
1231 ::flatbuffers::uoffset_t start_;
1232 void add_type_name(::flatbuffers::Offset<::flatbuffers::String> type_name) {
1233 fbb_.AddOffset(ObjectType::VT_TYPE_NAME, type_name);
1234 }
1235 void add_type(torch::jit::mobile::serialization::TypeType type) {
1236 fbb_.AddElement<uint8_t>(ObjectType::VT_TYPE, static_cast<uint8_t>(type), 0);
1237 }
1238 void add_attr_names(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> attr_names) {
1239 fbb_.AddOffset(ObjectType::VT_ATTR_NAMES, attr_names);
1240 }
1241 explicit ObjectTypeBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1242 : fbb_(_fbb) {
1243 start_ = fbb_.StartTable();
1244 }
1245 ::flatbuffers::Offset<ObjectType> Finish() {
1246 const auto end = fbb_.EndTable(start_);
1247 auto o = ::flatbuffers::Offset<ObjectType>(end);
1248 return o;
1249 }
1250 };
1251
1252 inline ::flatbuffers::Offset<ObjectType> CreateObjectType(
1253 ::flatbuffers::FlatBufferBuilder &_fbb,
1254 ::flatbuffers::Offset<::flatbuffers::String> type_name = 0,
1255 torch::jit::mobile::serialization::TypeType type = torch::jit::mobile::serialization::TypeType::UNSET,
1256 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> attr_names = 0) {
1257 ObjectTypeBuilder builder_(_fbb);
1258 builder_.add_attr_names(attr_names);
1259 builder_.add_type_name(type_name);
1260 builder_.add_type(type);
1261 return builder_.Finish();
1262 }
1263
1264 inline ::flatbuffers::Offset<ObjectType> CreateObjectTypeDirect(
1265 ::flatbuffers::FlatBufferBuilder &_fbb,
1266 const char *type_name = nullptr,
1267 torch::jit::mobile::serialization::TypeType type = torch::jit::mobile::serialization::TypeType::UNSET,
1268 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *attr_names = nullptr) {
1269 auto type_name__ = type_name ? _fbb.CreateString(type_name) : 0;
1270 auto attr_names__ = attr_names ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*attr_names) : 0;
1271 return torch::jit::mobile::serialization::CreateObjectType(
1272 _fbb,
1273 type_name__,
1274 type,
1275 attr_names__);
1276 }
1277
1278 struct Object FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1279 typedef ObjectBuilder Builder;
1280 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1281 VT_TYPE_INDEX = 4,
1282 VT_STATE = 6,
1283 VT_ATTRS = 8,
1284 VT_SETSTATE_FUNC = 10
1285 };
1286 uint32_t type_index() const {
1287 return GetField<uint32_t>(VT_TYPE_INDEX, 0);
1288 }
1289 bool mutate_type_index(uint32_t _type_index = 0) {
1290 return SetField<uint32_t>(VT_TYPE_INDEX, _type_index, 0);
1291 }
1292 uint32_t state() const {
1293 return GetField<uint32_t>(VT_STATE, 0);
1294 }
1295 bool mutate_state(uint32_t _state = 0) {
1296 return SetField<uint32_t>(VT_STATE, _state, 0);
1297 }
1298 const ::flatbuffers::Vector<uint32_t> *attrs() const {
1299 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_ATTRS);
1300 }
1301 ::flatbuffers::Vector<uint32_t> *mutable_attrs() {
1302 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_ATTRS);
1303 }
1304 uint32_t setstate_func() const {
1305 return GetField<uint32_t>(VT_SETSTATE_FUNC, 0);
1306 }
1307 bool mutate_setstate_func(uint32_t _setstate_func = 0) {
1308 return SetField<uint32_t>(VT_SETSTATE_FUNC, _setstate_func, 0);
1309 }
1310 bool Verify(::flatbuffers::Verifier &verifier) const {
1311 return VerifyTableStart(verifier) &&
1312 VerifyField<uint32_t>(verifier, VT_TYPE_INDEX, 4) &&
1313 VerifyField<uint32_t>(verifier, VT_STATE, 4) &&
1314 VerifyOffset(verifier, VT_ATTRS) &&
1315 verifier.VerifyVector(attrs()) &&
1316 VerifyField<uint32_t>(verifier, VT_SETSTATE_FUNC, 4) &&
1317 verifier.EndTable();
1318 }
1319 };
1320
1321 struct ObjectBuilder {
1322 typedef Object Table;
1323 ::flatbuffers::FlatBufferBuilder &fbb_;
1324 ::flatbuffers::uoffset_t start_;
1325 void add_type_index(uint32_t type_index) {
1326 fbb_.AddElement<uint32_t>(Object::VT_TYPE_INDEX, type_index, 0);
1327 }
1328 void add_state(uint32_t state) {
1329 fbb_.AddElement<uint32_t>(Object::VT_STATE, state, 0);
1330 }
1331 void add_attrs(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> attrs) {
1332 fbb_.AddOffset(Object::VT_ATTRS, attrs);
1333 }
1334 void add_setstate_func(uint32_t setstate_func) {
1335 fbb_.AddElement<uint32_t>(Object::VT_SETSTATE_FUNC, setstate_func, 0);
1336 }
1337 explicit ObjectBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1338 : fbb_(_fbb) {
1339 start_ = fbb_.StartTable();
1340 }
1341 ::flatbuffers::Offset<Object> Finish() {
1342 const auto end = fbb_.EndTable(start_);
1343 auto o = ::flatbuffers::Offset<Object>(end);
1344 return o;
1345 }
1346 };
1347
1348 inline ::flatbuffers::Offset<Object> CreateObject(
1349 ::flatbuffers::FlatBufferBuilder &_fbb,
1350 uint32_t type_index = 0,
1351 uint32_t state = 0,
1352 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> attrs = 0,
1353 uint32_t setstate_func = 0) {
1354 ObjectBuilder builder_(_fbb);
1355 builder_.add_setstate_func(setstate_func);
1356 builder_.add_attrs(attrs);
1357 builder_.add_state(state);
1358 builder_.add_type_index(type_index);
1359 return builder_.Finish();
1360 }
1361
1362 inline ::flatbuffers::Offset<Object> CreateObjectDirect(
1363 ::flatbuffers::FlatBufferBuilder &_fbb,
1364 uint32_t type_index = 0,
1365 uint32_t state = 0,
1366 const std::vector<uint32_t> *attrs = nullptr,
1367 uint32_t setstate_func = 0) {
1368 auto attrs__ = attrs ? _fbb.CreateVector<uint32_t>(*attrs) : 0;
1369 return torch::jit::mobile::serialization::CreateObject(
1370 _fbb,
1371 type_index,
1372 state,
1373 attrs__,
1374 setstate_func);
1375 }
1376
1377 struct EnumValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1378 typedef EnumValueBuilder Builder;
1379 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1380 VT_TYPE_NAME = 4,
1381 VT_VALUE = 6
1382 };
1383 const ::flatbuffers::String *type_name() const {
1384 return GetPointer<const ::flatbuffers::String *>(VT_TYPE_NAME);
1385 }
1386 ::flatbuffers::String *mutable_type_name() {
1387 return GetPointer<::flatbuffers::String *>(VT_TYPE_NAME);
1388 }
1389 uint32_t value() const {
1390 return GetField<uint32_t>(VT_VALUE, 0);
1391 }
1392 bool mutate_value(uint32_t _value = 0) {
1393 return SetField<uint32_t>(VT_VALUE, _value, 0);
1394 }
1395 bool Verify(::flatbuffers::Verifier &verifier) const {
1396 return VerifyTableStart(verifier) &&
1397 VerifyOffset(verifier, VT_TYPE_NAME) &&
1398 verifier.VerifyString(type_name()) &&
1399 VerifyField<uint32_t>(verifier, VT_VALUE, 4) &&
1400 verifier.EndTable();
1401 }
1402 };
1403
1404 struct EnumValueBuilder {
1405 typedef EnumValue Table;
1406 ::flatbuffers::FlatBufferBuilder &fbb_;
1407 ::flatbuffers::uoffset_t start_;
1408 void add_type_name(::flatbuffers::Offset<::flatbuffers::String> type_name) {
1409 fbb_.AddOffset(EnumValue::VT_TYPE_NAME, type_name);
1410 }
1411 void add_value(uint32_t value) {
1412 fbb_.AddElement<uint32_t>(EnumValue::VT_VALUE, value, 0);
1413 }
1414 explicit EnumValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1415 : fbb_(_fbb) {
1416 start_ = fbb_.StartTable();
1417 }
1418 ::flatbuffers::Offset<EnumValue> Finish() {
1419 const auto end = fbb_.EndTable(start_);
1420 auto o = ::flatbuffers::Offset<EnumValue>(end);
1421 return o;
1422 }
1423 };
1424
1425 inline ::flatbuffers::Offset<EnumValue> CreateEnumValue(
1426 ::flatbuffers::FlatBufferBuilder &_fbb,
1427 ::flatbuffers::Offset<::flatbuffers::String> type_name = 0,
1428 uint32_t value = 0) {
1429 EnumValueBuilder builder_(_fbb);
1430 builder_.add_value(value);
1431 builder_.add_type_name(type_name);
1432 return builder_.Finish();
1433 }
1434
1435 inline ::flatbuffers::Offset<EnumValue> CreateEnumValueDirect(
1436 ::flatbuffers::FlatBufferBuilder &_fbb,
1437 const char *type_name = nullptr,
1438 uint32_t value = 0) {
1439 auto type_name__ = type_name ? _fbb.CreateString(type_name) : 0;
1440 return torch::jit::mobile::serialization::CreateEnumValue(
1441 _fbb,
1442 type_name__,
1443 value);
1444 }
1445
1446 struct Operator FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1447 typedef OperatorBuilder Builder;
1448 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1449 VT_NAME = 4,
1450 VT_OVERLOAD_NAME = 6,
1451 VT_NUM_ARGS_SERIALIZED = 8
1452 };
1453 const ::flatbuffers::String *name() const {
1454 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
1455 }
1456 ::flatbuffers::String *mutable_name() {
1457 return GetPointer<::flatbuffers::String *>(VT_NAME);
1458 }
1459 const ::flatbuffers::String *overload_name() const {
1460 return GetPointer<const ::flatbuffers::String *>(VT_OVERLOAD_NAME);
1461 }
1462 ::flatbuffers::String *mutable_overload_name() {
1463 return GetPointer<::flatbuffers::String *>(VT_OVERLOAD_NAME);
1464 }
1465 int32_t num_args_serialized() const {
1466 return GetField<int32_t>(VT_NUM_ARGS_SERIALIZED, -1);
1467 }
1468 bool mutate_num_args_serialized(int32_t _num_args_serialized = -1) {
1469 return SetField<int32_t>(VT_NUM_ARGS_SERIALIZED, _num_args_serialized, -1);
1470 }
1471 bool Verify(::flatbuffers::Verifier &verifier) const {
1472 return VerifyTableStart(verifier) &&
1473 VerifyOffset(verifier, VT_NAME) &&
1474 verifier.VerifyString(name()) &&
1475 VerifyOffset(verifier, VT_OVERLOAD_NAME) &&
1476 verifier.VerifyString(overload_name()) &&
1477 VerifyField<int32_t>(verifier, VT_NUM_ARGS_SERIALIZED, 4) &&
1478 verifier.EndTable();
1479 }
1480 };
1481
1482 struct OperatorBuilder {
1483 typedef Operator Table;
1484 ::flatbuffers::FlatBufferBuilder &fbb_;
1485 ::flatbuffers::uoffset_t start_;
1486 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
1487 fbb_.AddOffset(Operator::VT_NAME, name);
1488 }
1489 void add_overload_name(::flatbuffers::Offset<::flatbuffers::String> overload_name) {
1490 fbb_.AddOffset(Operator::VT_OVERLOAD_NAME, overload_name);
1491 }
1492 void add_num_args_serialized(int32_t num_args_serialized) {
1493 fbb_.AddElement<int32_t>(Operator::VT_NUM_ARGS_SERIALIZED, num_args_serialized, -1);
1494 }
1495 explicit OperatorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1496 : fbb_(_fbb) {
1497 start_ = fbb_.StartTable();
1498 }
1499 ::flatbuffers::Offset<Operator> Finish() {
1500 const auto end = fbb_.EndTable(start_);
1501 auto o = ::flatbuffers::Offset<Operator>(end);
1502 return o;
1503 }
1504 };
1505
1506 inline ::flatbuffers::Offset<Operator> CreateOperator(
1507 ::flatbuffers::FlatBufferBuilder &_fbb,
1508 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
1509 ::flatbuffers::Offset<::flatbuffers::String> overload_name = 0,
1510 int32_t num_args_serialized = -1) {
1511 OperatorBuilder builder_(_fbb);
1512 builder_.add_num_args_serialized(num_args_serialized);
1513 builder_.add_overload_name(overload_name);
1514 builder_.add_name(name);
1515 return builder_.Finish();
1516 }
1517
1518 inline ::flatbuffers::Offset<Operator> CreateOperatorDirect(
1519 ::flatbuffers::FlatBufferBuilder &_fbb,
1520 const char *name = nullptr,
1521 const char *overload_name = nullptr,
1522 int32_t num_args_serialized = -1) {
1523 auto name__ = name ? _fbb.CreateString(name) : 0;
1524 auto overload_name__ = overload_name ? _fbb.CreateString(overload_name) : 0;
1525 return torch::jit::mobile::serialization::CreateOperator(
1526 _fbb,
1527 name__,
1528 overload_name__,
1529 num_args_serialized);
1530 }
1531
1532 struct Arg FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1533 typedef ArgBuilder Builder;
1534 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1535 VT_NAME = 4,
1536 VT_TYPE = 6,
1537 VT_DEFAULT_VALUE = 8
1538 };
1539 const ::flatbuffers::String *name() const {
1540 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
1541 }
1542 ::flatbuffers::String *mutable_name() {
1543 return GetPointer<::flatbuffers::String *>(VT_NAME);
1544 }
1545 const ::flatbuffers::String *type() const {
1546 return GetPointer<const ::flatbuffers::String *>(VT_TYPE);
1547 }
1548 ::flatbuffers::String *mutable_type() {
1549 return GetPointer<::flatbuffers::String *>(VT_TYPE);
1550 }
1551 uint32_t default_value() const {
1552 return GetField<uint32_t>(VT_DEFAULT_VALUE, 0);
1553 }
1554 bool mutate_default_value(uint32_t _default_value = 0) {
1555 return SetField<uint32_t>(VT_DEFAULT_VALUE, _default_value, 0);
1556 }
1557 bool Verify(::flatbuffers::Verifier &verifier) const {
1558 return VerifyTableStart(verifier) &&
1559 VerifyOffset(verifier, VT_NAME) &&
1560 verifier.VerifyString(name()) &&
1561 VerifyOffset(verifier, VT_TYPE) &&
1562 verifier.VerifyString(type()) &&
1563 VerifyField<uint32_t>(verifier, VT_DEFAULT_VALUE, 4) &&
1564 verifier.EndTable();
1565 }
1566 };
1567
1568 struct ArgBuilder {
1569 typedef Arg Table;
1570 ::flatbuffers::FlatBufferBuilder &fbb_;
1571 ::flatbuffers::uoffset_t start_;
1572 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
1573 fbb_.AddOffset(Arg::VT_NAME, name);
1574 }
1575 void add_type(::flatbuffers::Offset<::flatbuffers::String> type) {
1576 fbb_.AddOffset(Arg::VT_TYPE, type);
1577 }
1578 void add_default_value(uint32_t default_value) {
1579 fbb_.AddElement<uint32_t>(Arg::VT_DEFAULT_VALUE, default_value, 0);
1580 }
1581 explicit ArgBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1582 : fbb_(_fbb) {
1583 start_ = fbb_.StartTable();
1584 }
1585 ::flatbuffers::Offset<Arg> Finish() {
1586 const auto end = fbb_.EndTable(start_);
1587 auto o = ::flatbuffers::Offset<Arg>(end);
1588 return o;
1589 }
1590 };
1591
1592 inline ::flatbuffers::Offset<Arg> CreateArg(
1593 ::flatbuffers::FlatBufferBuilder &_fbb,
1594 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
1595 ::flatbuffers::Offset<::flatbuffers::String> type = 0,
1596 uint32_t default_value = 0) {
1597 ArgBuilder builder_(_fbb);
1598 builder_.add_default_value(default_value);
1599 builder_.add_type(type);
1600 builder_.add_name(name);
1601 return builder_.Finish();
1602 }
1603
1604 inline ::flatbuffers::Offset<Arg> CreateArgDirect(
1605 ::flatbuffers::FlatBufferBuilder &_fbb,
1606 const char *name = nullptr,
1607 const char *type = nullptr,
1608 uint32_t default_value = 0) {
1609 auto name__ = name ? _fbb.CreateString(name) : 0;
1610 auto type__ = type ? _fbb.CreateString(type) : 0;
1611 return torch::jit::mobile::serialization::CreateArg(
1612 _fbb,
1613 name__,
1614 type__,
1615 default_value);
1616 }
1617
1618 struct Schema FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1619 typedef SchemaBuilder Builder;
1620 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1621 VT_ARGUMENTS = 4,
1622 VT_RETURNS = 6
1623 };
1624 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *arguments() const {
1625 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *>(VT_ARGUMENTS);
1626 }
1627 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *mutable_arguments() {
1628 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *>(VT_ARGUMENTS);
1629 }
1630 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *returns() const {
1631 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *>(VT_RETURNS);
1632 }
1633 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *mutable_returns() {
1634 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *>(VT_RETURNS);
1635 }
1636 bool Verify(::flatbuffers::Verifier &verifier) const {
1637 return VerifyTableStart(verifier) &&
1638 VerifyOffset(verifier, VT_ARGUMENTS) &&
1639 verifier.VerifyVector(arguments()) &&
1640 verifier.VerifyVectorOfTables(arguments()) &&
1641 VerifyOffset(verifier, VT_RETURNS) &&
1642 verifier.VerifyVector(returns()) &&
1643 verifier.VerifyVectorOfTables(returns()) &&
1644 verifier.EndTable();
1645 }
1646 };
1647
1648 struct SchemaBuilder {
1649 typedef Schema Table;
1650 ::flatbuffers::FlatBufferBuilder &fbb_;
1651 ::flatbuffers::uoffset_t start_;
1652 void add_arguments(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>>> arguments) {
1653 fbb_.AddOffset(Schema::VT_ARGUMENTS, arguments);
1654 }
1655 void add_returns(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>>> returns) {
1656 fbb_.AddOffset(Schema::VT_RETURNS, returns);
1657 }
1658 explicit SchemaBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1659 : fbb_(_fbb) {
1660 start_ = fbb_.StartTable();
1661 }
1662 ::flatbuffers::Offset<Schema> Finish() {
1663 const auto end = fbb_.EndTable(start_);
1664 auto o = ::flatbuffers::Offset<Schema>(end);
1665 return o;
1666 }
1667 };
1668
1669 inline ::flatbuffers::Offset<Schema> CreateSchema(
1670 ::flatbuffers::FlatBufferBuilder &_fbb,
1671 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>>> arguments = 0,
1672 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>>> returns = 0) {
1673 SchemaBuilder builder_(_fbb);
1674 builder_.add_returns(returns);
1675 builder_.add_arguments(arguments);
1676 return builder_.Finish();
1677 }
1678
1679 inline ::flatbuffers::Offset<Schema> CreateSchemaDirect(
1680 ::flatbuffers::FlatBufferBuilder &_fbb,
1681 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *arguments = nullptr,
1682 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>> *returns = nullptr) {
1683 auto arguments__ = arguments ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>>(*arguments) : 0;
1684 auto returns__ = returns ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::Arg>>(*returns) : 0;
1685 return torch::jit::mobile::serialization::CreateSchema(
1686 _fbb,
1687 arguments__,
1688 returns__);
1689 }
1690
1691 struct DebugInfo FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1692 typedef DebugInfoBuilder Builder;
1693 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1694 VT_DEBUG_HANDLE = 4
1695 };
1696 const ::flatbuffers::Vector<int64_t> *debug_handle() const {
1697 return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_DEBUG_HANDLE);
1698 }
1699 ::flatbuffers::Vector<int64_t> *mutable_debug_handle() {
1700 return GetPointer<::flatbuffers::Vector<int64_t> *>(VT_DEBUG_HANDLE);
1701 }
1702 bool Verify(::flatbuffers::Verifier &verifier) const {
1703 return VerifyTableStart(verifier) &&
1704 VerifyOffset(verifier, VT_DEBUG_HANDLE) &&
1705 verifier.VerifyVector(debug_handle()) &&
1706 verifier.EndTable();
1707 }
1708 };
1709
1710 struct DebugInfoBuilder {
1711 typedef DebugInfo Table;
1712 ::flatbuffers::FlatBufferBuilder &fbb_;
1713 ::flatbuffers::uoffset_t start_;
1714 void add_debug_handle(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> debug_handle) {
1715 fbb_.AddOffset(DebugInfo::VT_DEBUG_HANDLE, debug_handle);
1716 }
1717 explicit DebugInfoBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1718 : fbb_(_fbb) {
1719 start_ = fbb_.StartTable();
1720 }
1721 ::flatbuffers::Offset<DebugInfo> Finish() {
1722 const auto end = fbb_.EndTable(start_);
1723 auto o = ::flatbuffers::Offset<DebugInfo>(end);
1724 return o;
1725 }
1726 };
1727
1728 inline ::flatbuffers::Offset<DebugInfo> CreateDebugInfo(
1729 ::flatbuffers::FlatBufferBuilder &_fbb,
1730 ::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> debug_handle = 0) {
1731 DebugInfoBuilder builder_(_fbb);
1732 builder_.add_debug_handle(debug_handle);
1733 return builder_.Finish();
1734 }
1735
1736 inline ::flatbuffers::Offset<DebugInfo> CreateDebugInfoDirect(
1737 ::flatbuffers::FlatBufferBuilder &_fbb,
1738 const std::vector<int64_t> *debug_handle = nullptr) {
1739 auto debug_handle__ = debug_handle ? _fbb.CreateVector<int64_t>(*debug_handle) : 0;
1740 return torch::jit::mobile::serialization::CreateDebugInfo(
1741 _fbb,
1742 debug_handle__);
1743 }
1744
1745 struct Function FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1746 typedef FunctionBuilder Builder;
1747 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1748 VT_QN = 4,
1749 VT_INSTRUCTIONS = 6,
1750 VT_OPERATORS = 8,
1751 VT_CONSTANTS = 10,
1752 VT_TYPE_ANNOTATIONS = 12,
1753 VT_REGISTER_SIZE = 14,
1754 VT_SCHEMA = 16,
1755 VT_DEBUG_INFO = 18,
1756 VT_CLASS_TYPE = 20
1757 };
1758 const ::flatbuffers::String *qn() const {
1759 return GetPointer<const ::flatbuffers::String *>(VT_QN);
1760 }
1761 ::flatbuffers::String *mutable_qn() {
1762 return GetPointer<::flatbuffers::String *>(VT_QN);
1763 }
1764 const ::flatbuffers::Vector<const torch::jit::mobile::serialization::Instruction *> *instructions() const {
1765 return GetPointer<const ::flatbuffers::Vector<const torch::jit::mobile::serialization::Instruction *> *>(VT_INSTRUCTIONS);
1766 }
1767 ::flatbuffers::Vector<const torch::jit::mobile::serialization::Instruction *> *mutable_instructions() {
1768 return GetPointer<::flatbuffers::Vector<const torch::jit::mobile::serialization::Instruction *> *>(VT_INSTRUCTIONS);
1769 }
1770 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>> *operators() const {
1771 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>> *>(VT_OPERATORS);
1772 }
1773 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>> *mutable_operators() {
1774 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>> *>(VT_OPERATORS);
1775 }
1776 const ::flatbuffers::Vector<uint32_t> *constants() const {
1777 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_CONSTANTS);
1778 }
1779 ::flatbuffers::Vector<uint32_t> *mutable_constants() {
1780 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_CONSTANTS);
1781 }
1782 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *type_annotations() const {
1783 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TYPE_ANNOTATIONS);
1784 }
1785 ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *mutable_type_annotations() {
1786 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_TYPE_ANNOTATIONS);
1787 }
1788 int32_t register_size() const {
1789 return GetField<int32_t>(VT_REGISTER_SIZE, 0);
1790 }
1791 bool mutate_register_size(int32_t _register_size = 0) {
1792 return SetField<int32_t>(VT_REGISTER_SIZE, _register_size, 0);
1793 }
1794 const torch::jit::mobile::serialization::Schema *schema() const {
1795 return GetPointer<const torch::jit::mobile::serialization::Schema *>(VT_SCHEMA);
1796 }
1797 torch::jit::mobile::serialization::Schema *mutable_schema() {
1798 return GetPointer<torch::jit::mobile::serialization::Schema *>(VT_SCHEMA);
1799 }
1800 const torch::jit::mobile::serialization::DebugInfo *debug_info() const {
1801 return GetPointer<const torch::jit::mobile::serialization::DebugInfo *>(VT_DEBUG_INFO);
1802 }
1803 torch::jit::mobile::serialization::DebugInfo *mutable_debug_info() {
1804 return GetPointer<torch::jit::mobile::serialization::DebugInfo *>(VT_DEBUG_INFO);
1805 }
1806 uint32_t class_type() const {
1807 return GetField<uint32_t>(VT_CLASS_TYPE, 0);
1808 }
1809 bool mutate_class_type(uint32_t _class_type = 0) {
1810 return SetField<uint32_t>(VT_CLASS_TYPE, _class_type, 0);
1811 }
1812 bool Verify(::flatbuffers::Verifier &verifier) const {
1813 return VerifyTableStart(verifier) &&
1814 VerifyOffset(verifier, VT_QN) &&
1815 verifier.VerifyString(qn()) &&
1816 VerifyOffset(verifier, VT_INSTRUCTIONS) &&
1817 verifier.VerifyVector(instructions()) &&
1818 VerifyOffset(verifier, VT_OPERATORS) &&
1819 verifier.VerifyVector(operators()) &&
1820 verifier.VerifyVectorOfTables(operators()) &&
1821 VerifyOffset(verifier, VT_CONSTANTS) &&
1822 verifier.VerifyVector(constants()) &&
1823 VerifyOffset(verifier, VT_TYPE_ANNOTATIONS) &&
1824 verifier.VerifyVector(type_annotations()) &&
1825 verifier.VerifyVectorOfStrings(type_annotations()) &&
1826 VerifyField<int32_t>(verifier, VT_REGISTER_SIZE, 4) &&
1827 VerifyOffset(verifier, VT_SCHEMA) &&
1828 verifier.VerifyTable(schema()) &&
1829 VerifyOffset(verifier, VT_DEBUG_INFO) &&
1830 verifier.VerifyTable(debug_info()) &&
1831 VerifyField<uint32_t>(verifier, VT_CLASS_TYPE, 4) &&
1832 verifier.EndTable();
1833 }
1834 };
1835
1836 struct FunctionBuilder {
1837 typedef Function Table;
1838 ::flatbuffers::FlatBufferBuilder &fbb_;
1839 ::flatbuffers::uoffset_t start_;
1840 void add_qn(::flatbuffers::Offset<::flatbuffers::String> qn) {
1841 fbb_.AddOffset(Function::VT_QN, qn);
1842 }
1843 void add_instructions(::flatbuffers::Offset<::flatbuffers::Vector<const torch::jit::mobile::serialization::Instruction *>> instructions) {
1844 fbb_.AddOffset(Function::VT_INSTRUCTIONS, instructions);
1845 }
1846 void add_operators(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>>> operators) {
1847 fbb_.AddOffset(Function::VT_OPERATORS, operators);
1848 }
1849 void add_constants(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> constants) {
1850 fbb_.AddOffset(Function::VT_CONSTANTS, constants);
1851 }
1852 void add_type_annotations(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> type_annotations) {
1853 fbb_.AddOffset(Function::VT_TYPE_ANNOTATIONS, type_annotations);
1854 }
1855 void add_register_size(int32_t register_size) {
1856 fbb_.AddElement<int32_t>(Function::VT_REGISTER_SIZE, register_size, 0);
1857 }
1858 void add_schema(::flatbuffers::Offset<torch::jit::mobile::serialization::Schema> schema) {
1859 fbb_.AddOffset(Function::VT_SCHEMA, schema);
1860 }
1861 void add_debug_info(::flatbuffers::Offset<torch::jit::mobile::serialization::DebugInfo> debug_info) {
1862 fbb_.AddOffset(Function::VT_DEBUG_INFO, debug_info);
1863 }
1864 void add_class_type(uint32_t class_type) {
1865 fbb_.AddElement<uint32_t>(Function::VT_CLASS_TYPE, class_type, 0);
1866 }
1867 explicit FunctionBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1868 : fbb_(_fbb) {
1869 start_ = fbb_.StartTable();
1870 }
1871 ::flatbuffers::Offset<Function> Finish() {
1872 const auto end = fbb_.EndTable(start_);
1873 auto o = ::flatbuffers::Offset<Function>(end);
1874 return o;
1875 }
1876 };
1877
1878 inline ::flatbuffers::Offset<Function> CreateFunction(
1879 ::flatbuffers::FlatBufferBuilder &_fbb,
1880 ::flatbuffers::Offset<::flatbuffers::String> qn = 0,
1881 ::flatbuffers::Offset<::flatbuffers::Vector<const torch::jit::mobile::serialization::Instruction *>> instructions = 0,
1882 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>>> operators = 0,
1883 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> constants = 0,
1884 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> type_annotations = 0,
1885 int32_t register_size = 0,
1886 ::flatbuffers::Offset<torch::jit::mobile::serialization::Schema> schema = 0,
1887 ::flatbuffers::Offset<torch::jit::mobile::serialization::DebugInfo> debug_info = 0,
1888 uint32_t class_type = 0) {
1889 FunctionBuilder builder_(_fbb);
1890 builder_.add_class_type(class_type);
1891 builder_.add_debug_info(debug_info);
1892 builder_.add_schema(schema);
1893 builder_.add_register_size(register_size);
1894 builder_.add_type_annotations(type_annotations);
1895 builder_.add_constants(constants);
1896 builder_.add_operators(operators);
1897 builder_.add_instructions(instructions);
1898 builder_.add_qn(qn);
1899 return builder_.Finish();
1900 }
1901
1902 inline ::flatbuffers::Offset<Function> CreateFunctionDirect(
1903 ::flatbuffers::FlatBufferBuilder &_fbb,
1904 const char *qn = nullptr,
1905 const std::vector<torch::jit::mobile::serialization::Instruction> *instructions = nullptr,
1906 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>> *operators = nullptr,
1907 const std::vector<uint32_t> *constants = nullptr,
1908 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *type_annotations = nullptr,
1909 int32_t register_size = 0,
1910 ::flatbuffers::Offset<torch::jit::mobile::serialization::Schema> schema = 0,
1911 ::flatbuffers::Offset<torch::jit::mobile::serialization::DebugInfo> debug_info = 0,
1912 uint32_t class_type = 0) {
1913 auto qn__ = qn ? _fbb.CreateString(qn) : 0;
1914 auto instructions__ = instructions ? _fbb.CreateVectorOfStructs<torch::jit::mobile::serialization::Instruction>(*instructions) : 0;
1915 auto operators__ = operators ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::Operator>>(*operators) : 0;
1916 auto constants__ = constants ? _fbb.CreateVector<uint32_t>(*constants) : 0;
1917 auto type_annotations__ = type_annotations ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*type_annotations) : 0;
1918 return torch::jit::mobile::serialization::CreateFunction(
1919 _fbb,
1920 qn__,
1921 instructions__,
1922 operators__,
1923 constants__,
1924 type_annotations__,
1925 register_size,
1926 schema,
1927 debug_info,
1928 class_type);
1929 }
1930
1931 struct StorageData FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1932 typedef StorageDataBuilder Builder;
1933 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1934 VT_DATA = 4
1935 };
1936 const ::flatbuffers::Vector<uint8_t> *data() const {
1937 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA);
1938 }
1939 ::flatbuffers::Vector<uint8_t> *mutable_data() {
1940 return GetPointer<::flatbuffers::Vector<uint8_t> *>(VT_DATA);
1941 }
1942 bool Verify(::flatbuffers::Verifier &verifier) const {
1943 return VerifyTableStart(verifier) &&
1944 VerifyOffset(verifier, VT_DATA) &&
1945 verifier.VerifyVector(data()) &&
1946 verifier.EndTable();
1947 }
1948 };
1949
1950 struct StorageDataBuilder {
1951 typedef StorageData Table;
1952 ::flatbuffers::FlatBufferBuilder &fbb_;
1953 ::flatbuffers::uoffset_t start_;
1954 void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) {
1955 fbb_.AddOffset(StorageData::VT_DATA, data);
1956 }
1957 explicit StorageDataBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
1958 : fbb_(_fbb) {
1959 start_ = fbb_.StartTable();
1960 }
1961 ::flatbuffers::Offset<StorageData> Finish() {
1962 const auto end = fbb_.EndTable(start_);
1963 auto o = ::flatbuffers::Offset<StorageData>(end);
1964 return o;
1965 }
1966 };
1967
1968 inline ::flatbuffers::Offset<StorageData> CreateStorageData(
1969 ::flatbuffers::FlatBufferBuilder &_fbb,
1970 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) {
1971 StorageDataBuilder builder_(_fbb);
1972 builder_.add_data(data);
1973 return builder_.Finish();
1974 }
1975
1976 inline ::flatbuffers::Offset<StorageData> CreateStorageDataDirect(
1977 ::flatbuffers::FlatBufferBuilder &_fbb,
1978 const std::vector<uint8_t> *data = nullptr) {
1979 if (data) { _fbb.ForceVectorAlignment(data->size(), sizeof(uint8_t), 16); }
1980 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1981 return torch::jit::mobile::serialization::CreateStorageData(
1982 _fbb,
1983 data__);
1984 }
1985
1986 struct IValue FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
1987 typedef IValueBuilder Builder;
1988 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1989 VT_VAL_TYPE = 4,
1990 VT_VAL = 6
1991 };
1992 torch::jit::mobile::serialization::IValueUnion val_type() const {
1993 return static_cast<torch::jit::mobile::serialization::IValueUnion>(GetField<uint8_t>(VT_VAL_TYPE, 0));
1994 }
1995 const void *val() const {
1996 return GetPointer<const void *>(VT_VAL);
1997 }
1998 template<typename T> const T *val_as() const;
1999 const torch::jit::mobile::serialization::Int *val_as_Int() const {
2000 return val_type() == torch::jit::mobile::serialization::IValueUnion::Int ? static_cast<const torch::jit::mobile::serialization::Int *>(val()) : nullptr;
2001 }
2002 const torch::jit::mobile::serialization::Bool *val_as_Bool() const {
2003 return val_type() == torch::jit::mobile::serialization::IValueUnion::Bool ? static_cast<const torch::jit::mobile::serialization::Bool *>(val()) : nullptr;
2004 }
2005 const torch::jit::mobile::serialization::Double *val_as_Double() const {
2006 return val_type() == torch::jit::mobile::serialization::IValueUnion::Double ? static_cast<const torch::jit::mobile::serialization::Double *>(val()) : nullptr;
2007 }
2008 const torch::jit::mobile::serialization::ComplexDouble *val_as_ComplexDouble() const {
2009 return val_type() == torch::jit::mobile::serialization::IValueUnion::ComplexDouble ? static_cast<const torch::jit::mobile::serialization::ComplexDouble *>(val()) : nullptr;
2010 }
2011 const torch::jit::mobile::serialization::TensorMetadata *val_as_TensorMetadata() const {
2012 return val_type() == torch::jit::mobile::serialization::IValueUnion::TensorMetadata ? static_cast<const torch::jit::mobile::serialization::TensorMetadata *>(val()) : nullptr;
2013 }
2014 const torch::jit::mobile::serialization::String *val_as_String() const {
2015 return val_type() == torch::jit::mobile::serialization::IValueUnion::String ? static_cast<const torch::jit::mobile::serialization::String *>(val()) : nullptr;
2016 }
2017 const torch::jit::mobile::serialization::List *val_as_List() const {
2018 return val_type() == torch::jit::mobile::serialization::IValueUnion::List ? static_cast<const torch::jit::mobile::serialization::List *>(val()) : nullptr;
2019 }
2020 const torch::jit::mobile::serialization::Tuple *val_as_Tuple() const {
2021 return val_type() == torch::jit::mobile::serialization::IValueUnion::Tuple ? static_cast<const torch::jit::mobile::serialization::Tuple *>(val()) : nullptr;
2022 }
2023 const torch::jit::mobile::serialization::Dict *val_as_Dict() const {
2024 return val_type() == torch::jit::mobile::serialization::IValueUnion::Dict ? static_cast<const torch::jit::mobile::serialization::Dict *>(val()) : nullptr;
2025 }
2026 const torch::jit::mobile::serialization::Object *val_as_Object() const {
2027 return val_type() == torch::jit::mobile::serialization::IValueUnion::Object ? static_cast<const torch::jit::mobile::serialization::Object *>(val()) : nullptr;
2028 }
2029 const torch::jit::mobile::serialization::IntList *val_as_IntList() const {
2030 return val_type() == torch::jit::mobile::serialization::IValueUnion::IntList ? static_cast<const torch::jit::mobile::serialization::IntList *>(val()) : nullptr;
2031 }
2032 const torch::jit::mobile::serialization::DoubleList *val_as_DoubleList() const {
2033 return val_type() == torch::jit::mobile::serialization::IValueUnion::DoubleList ? static_cast<const torch::jit::mobile::serialization::DoubleList *>(val()) : nullptr;
2034 }
2035 const torch::jit::mobile::serialization::BoolList *val_as_BoolList() const {
2036 return val_type() == torch::jit::mobile::serialization::IValueUnion::BoolList ? static_cast<const torch::jit::mobile::serialization::BoolList *>(val()) : nullptr;
2037 }
2038 const torch::jit::mobile::serialization::Device *val_as_Device() const {
2039 return val_type() == torch::jit::mobile::serialization::IValueUnion::Device ? static_cast<const torch::jit::mobile::serialization::Device *>(val()) : nullptr;
2040 }
2041 const torch::jit::mobile::serialization::EnumValue *val_as_EnumValue() const {
2042 return val_type() == torch::jit::mobile::serialization::IValueUnion::EnumValue ? static_cast<const torch::jit::mobile::serialization::EnumValue *>(val()) : nullptr;
2043 }
2044 const torch::jit::mobile::serialization::Function *val_as_Function() const {
2045 return val_type() == torch::jit::mobile::serialization::IValueUnion::Function ? static_cast<const torch::jit::mobile::serialization::Function *>(val()) : nullptr;
2046 }
2047 void *mutable_val() {
2048 return GetPointer<void *>(VT_VAL);
2049 }
2050 bool Verify(::flatbuffers::Verifier &verifier) const {
2051 return VerifyTableStart(verifier) &&
2052 VerifyField<uint8_t>(verifier, VT_VAL_TYPE, 1) &&
2053 VerifyOffset(verifier, VT_VAL) &&
2054 VerifyIValueUnion(verifier, val(), val_type()) &&
2055 verifier.EndTable();
2056 }
2057 };
2058
2059 template<> inline const torch::jit::mobile::serialization::Int *IValue::val_as<torch::jit::mobile::serialization::Int>() const {
2060 return val_as_Int();
2061 }
2062
2063 template<> inline const torch::jit::mobile::serialization::Bool *IValue::val_as<torch::jit::mobile::serialization::Bool>() const {
2064 return val_as_Bool();
2065 }
2066
2067 template<> inline const torch::jit::mobile::serialization::Double *IValue::val_as<torch::jit::mobile::serialization::Double>() const {
2068 return val_as_Double();
2069 }
2070
2071 template<> inline const torch::jit::mobile::serialization::ComplexDouble *IValue::val_as<torch::jit::mobile::serialization::ComplexDouble>() const {
2072 return val_as_ComplexDouble();
2073 }
2074
2075 template<> inline const torch::jit::mobile::serialization::TensorMetadata *IValue::val_as<torch::jit::mobile::serialization::TensorMetadata>() const {
2076 return val_as_TensorMetadata();
2077 }
2078
2079 template<> inline const torch::jit::mobile::serialization::String *IValue::val_as<torch::jit::mobile::serialization::String>() const {
2080 return val_as_String();
2081 }
2082
2083 template<> inline const torch::jit::mobile::serialization::List *IValue::val_as<torch::jit::mobile::serialization::List>() const {
2084 return val_as_List();
2085 }
2086
2087 template<> inline const torch::jit::mobile::serialization::Tuple *IValue::val_as<torch::jit::mobile::serialization::Tuple>() const {
2088 return val_as_Tuple();
2089 }
2090
2091 template<> inline const torch::jit::mobile::serialization::Dict *IValue::val_as<torch::jit::mobile::serialization::Dict>() const {
2092 return val_as_Dict();
2093 }
2094
2095 template<> inline const torch::jit::mobile::serialization::Object *IValue::val_as<torch::jit::mobile::serialization::Object>() const {
2096 return val_as_Object();
2097 }
2098
2099 template<> inline const torch::jit::mobile::serialization::IntList *IValue::val_as<torch::jit::mobile::serialization::IntList>() const {
2100 return val_as_IntList();
2101 }
2102
2103 template<> inline const torch::jit::mobile::serialization::DoubleList *IValue::val_as<torch::jit::mobile::serialization::DoubleList>() const {
2104 return val_as_DoubleList();
2105 }
2106
2107 template<> inline const torch::jit::mobile::serialization::BoolList *IValue::val_as<torch::jit::mobile::serialization::BoolList>() const {
2108 return val_as_BoolList();
2109 }
2110
2111 template<> inline const torch::jit::mobile::serialization::Device *IValue::val_as<torch::jit::mobile::serialization::Device>() const {
2112 return val_as_Device();
2113 }
2114
2115 template<> inline const torch::jit::mobile::serialization::EnumValue *IValue::val_as<torch::jit::mobile::serialization::EnumValue>() const {
2116 return val_as_EnumValue();
2117 }
2118
2119 template<> inline const torch::jit::mobile::serialization::Function *IValue::val_as<torch::jit::mobile::serialization::Function>() const {
2120 return val_as_Function();
2121 }
2122
2123 struct IValueBuilder {
2124 typedef IValue Table;
2125 ::flatbuffers::FlatBufferBuilder &fbb_;
2126 ::flatbuffers::uoffset_t start_;
2127 void add_val_type(torch::jit::mobile::serialization::IValueUnion val_type) {
2128 fbb_.AddElement<uint8_t>(IValue::VT_VAL_TYPE, static_cast<uint8_t>(val_type), 0);
2129 }
2130 void add_val(::flatbuffers::Offset<void> val) {
2131 fbb_.AddOffset(IValue::VT_VAL, val);
2132 }
2133 explicit IValueBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
2134 : fbb_(_fbb) {
2135 start_ = fbb_.StartTable();
2136 }
2137 ::flatbuffers::Offset<IValue> Finish() {
2138 const auto end = fbb_.EndTable(start_);
2139 auto o = ::flatbuffers::Offset<IValue>(end);
2140 return o;
2141 }
2142 };
2143
2144 inline ::flatbuffers::Offset<IValue> CreateIValue(
2145 ::flatbuffers::FlatBufferBuilder &_fbb,
2146 torch::jit::mobile::serialization::IValueUnion val_type = torch::jit::mobile::serialization::IValueUnion::NONE,
2147 ::flatbuffers::Offset<void> val = 0) {
2148 IValueBuilder builder_(_fbb);
2149 builder_.add_val(val);
2150 builder_.add_val_type(val_type);
2151 return builder_.Finish();
2152 }
2153
2154 struct ExtraFile FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
2155 typedef ExtraFileBuilder Builder;
2156 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2157 VT_NAME = 4,
2158 VT_CONTENT = 6
2159 };
2160 const ::flatbuffers::String *name() const {
2161 return GetPointer<const ::flatbuffers::String *>(VT_NAME);
2162 }
2163 ::flatbuffers::String *mutable_name() {
2164 return GetPointer<::flatbuffers::String *>(VT_NAME);
2165 }
2166 const ::flatbuffers::String *content() const {
2167 return GetPointer<const ::flatbuffers::String *>(VT_CONTENT);
2168 }
2169 ::flatbuffers::String *mutable_content() {
2170 return GetPointer<::flatbuffers::String *>(VT_CONTENT);
2171 }
2172 bool Verify(::flatbuffers::Verifier &verifier) const {
2173 return VerifyTableStart(verifier) &&
2174 VerifyOffset(verifier, VT_NAME) &&
2175 verifier.VerifyString(name()) &&
2176 VerifyOffset(verifier, VT_CONTENT) &&
2177 verifier.VerifyString(content()) &&
2178 verifier.EndTable();
2179 }
2180 };
2181
2182 struct ExtraFileBuilder {
2183 typedef ExtraFile Table;
2184 ::flatbuffers::FlatBufferBuilder &fbb_;
2185 ::flatbuffers::uoffset_t start_;
2186 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) {
2187 fbb_.AddOffset(ExtraFile::VT_NAME, name);
2188 }
2189 void add_content(::flatbuffers::Offset<::flatbuffers::String> content) {
2190 fbb_.AddOffset(ExtraFile::VT_CONTENT, content);
2191 }
2192 explicit ExtraFileBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
2193 : fbb_(_fbb) {
2194 start_ = fbb_.StartTable();
2195 }
2196 ::flatbuffers::Offset<ExtraFile> Finish() {
2197 const auto end = fbb_.EndTable(start_);
2198 auto o = ::flatbuffers::Offset<ExtraFile>(end);
2199 return o;
2200 }
2201 };
2202
2203 inline ::flatbuffers::Offset<ExtraFile> CreateExtraFile(
2204 ::flatbuffers::FlatBufferBuilder &_fbb,
2205 ::flatbuffers::Offset<::flatbuffers::String> name = 0,
2206 ::flatbuffers::Offset<::flatbuffers::String> content = 0) {
2207 ExtraFileBuilder builder_(_fbb);
2208 builder_.add_content(content);
2209 builder_.add_name(name);
2210 return builder_.Finish();
2211 }
2212
2213 inline ::flatbuffers::Offset<ExtraFile> CreateExtraFileDirect(
2214 ::flatbuffers::FlatBufferBuilder &_fbb,
2215 const char *name = nullptr,
2216 const char *content = nullptr) {
2217 auto name__ = name ? _fbb.CreateString(name) : 0;
2218 auto content__ = content ? _fbb.CreateString(content) : 0;
2219 return torch::jit::mobile::serialization::CreateExtraFile(
2220 _fbb,
2221 name__,
2222 content__);
2223 }
2224
2225 struct Module FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
2226 typedef ModuleBuilder Builder;
2227 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2228 VT_BYTECODE_VERSION = 4,
2229 VT_EXTRA_FILES = 6,
2230 VT_METHODS = 8,
2231 VT_STATE_OBJ = 10,
2232 VT_IVALUES = 12,
2233 VT_STORAGE_DATA_SIZE = 14,
2234 VT_STORAGE_DATA = 16,
2235 VT_OBJECT_TYPES = 18,
2236 VT_JIT_SOURCES = 20,
2237 VT_JIT_CONSTANTS = 22,
2238 VT_OPERATOR_VERSION = 24,
2239 VT_MOBILE_IVALUE_SIZE = 26
2240 };
2241 uint32_t bytecode_version() const {
2242 return GetField<uint32_t>(VT_BYTECODE_VERSION, 0);
2243 }
2244 bool mutate_bytecode_version(uint32_t _bytecode_version = 0) {
2245 return SetField<uint32_t>(VT_BYTECODE_VERSION, _bytecode_version, 0);
2246 }
2247 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *extra_files() const {
2248 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *>(VT_EXTRA_FILES);
2249 }
2250 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *mutable_extra_files() {
2251 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *>(VT_EXTRA_FILES);
2252 }
2253 const ::flatbuffers::Vector<uint32_t> *methods() const {
2254 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_METHODS);
2255 }
2256 ::flatbuffers::Vector<uint32_t> *mutable_methods() {
2257 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_METHODS);
2258 }
2259 uint32_t state_obj() const {
2260 return GetField<uint32_t>(VT_STATE_OBJ, 0);
2261 }
2262 bool mutate_state_obj(uint32_t _state_obj = 0) {
2263 return SetField<uint32_t>(VT_STATE_OBJ, _state_obj, 0);
2264 }
2265 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>> *ivalues() const {
2266 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>> *>(VT_IVALUES);
2267 }
2268 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>> *mutable_ivalues() {
2269 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>> *>(VT_IVALUES);
2270 }
2271 int32_t storage_data_size() const {
2272 return GetField<int32_t>(VT_STORAGE_DATA_SIZE, 0);
2273 }
2274 bool mutate_storage_data_size(int32_t _storage_data_size = 0) {
2275 return SetField<int32_t>(VT_STORAGE_DATA_SIZE, _storage_data_size, 0);
2276 }
2277 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>> *storage_data() const {
2278 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>> *>(VT_STORAGE_DATA);
2279 }
2280 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>> *mutable_storage_data() {
2281 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>> *>(VT_STORAGE_DATA);
2282 }
2283 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>> *object_types() const {
2284 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>> *>(VT_OBJECT_TYPES);
2285 }
2286 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>> *mutable_object_types() {
2287 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>> *>(VT_OBJECT_TYPES);
2288 }
2289 const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *jit_sources() const {
2290 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *>(VT_JIT_SOURCES);
2291 }
2292 ::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *mutable_jit_sources() {
2293 return GetPointer<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *>(VT_JIT_SOURCES);
2294 }
2295 const ::flatbuffers::Vector<uint32_t> *jit_constants() const {
2296 return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_JIT_CONSTANTS);
2297 }
2298 ::flatbuffers::Vector<uint32_t> *mutable_jit_constants() {
2299 return GetPointer<::flatbuffers::Vector<uint32_t> *>(VT_JIT_CONSTANTS);
2300 }
2301 uint32_t operator_version() const {
2302 return GetField<uint32_t>(VT_OPERATOR_VERSION, 0);
2303 }
2304 bool mutate_operator_version(uint32_t _operator_version = 0) {
2305 return SetField<uint32_t>(VT_OPERATOR_VERSION, _operator_version, 0);
2306 }
2307 uint32_t mobile_ivalue_size() const {
2308 return GetField<uint32_t>(VT_MOBILE_IVALUE_SIZE, 0);
2309 }
2310 bool mutate_mobile_ivalue_size(uint32_t _mobile_ivalue_size = 0) {
2311 return SetField<uint32_t>(VT_MOBILE_IVALUE_SIZE, _mobile_ivalue_size, 0);
2312 }
2313 bool Verify(::flatbuffers::Verifier &verifier) const {
2314 return VerifyTableStart(verifier) &&
2315 VerifyField<uint32_t>(verifier, VT_BYTECODE_VERSION, 4) &&
2316 VerifyOffset(verifier, VT_EXTRA_FILES) &&
2317 verifier.VerifyVector(extra_files()) &&
2318 verifier.VerifyVectorOfTables(extra_files()) &&
2319 VerifyOffset(verifier, VT_METHODS) &&
2320 verifier.VerifyVector(methods()) &&
2321 VerifyField<uint32_t>(verifier, VT_STATE_OBJ, 4) &&
2322 VerifyOffset(verifier, VT_IVALUES) &&
2323 verifier.VerifyVector(ivalues()) &&
2324 verifier.VerifyVectorOfTables(ivalues()) &&
2325 VerifyField<int32_t>(verifier, VT_STORAGE_DATA_SIZE, 4) &&
2326 VerifyOffset(verifier, VT_STORAGE_DATA) &&
2327 verifier.VerifyVector(storage_data()) &&
2328 verifier.VerifyVectorOfTables(storage_data()) &&
2329 VerifyOffset(verifier, VT_OBJECT_TYPES) &&
2330 verifier.VerifyVector(object_types()) &&
2331 verifier.VerifyVectorOfTables(object_types()) &&
2332 VerifyOffset(verifier, VT_JIT_SOURCES) &&
2333 verifier.VerifyVector(jit_sources()) &&
2334 verifier.VerifyVectorOfTables(jit_sources()) &&
2335 VerifyOffset(verifier, VT_JIT_CONSTANTS) &&
2336 verifier.VerifyVector(jit_constants()) &&
2337 VerifyField<uint32_t>(verifier, VT_OPERATOR_VERSION, 4) &&
2338 VerifyField<uint32_t>(verifier, VT_MOBILE_IVALUE_SIZE, 4) &&
2339 verifier.EndTable();
2340 }
2341 };
2342
2343 struct ModuleBuilder {
2344 typedef Module Table;
2345 ::flatbuffers::FlatBufferBuilder &fbb_;
2346 ::flatbuffers::uoffset_t start_;
2347 void add_bytecode_version(uint32_t bytecode_version) {
2348 fbb_.AddElement<uint32_t>(Module::VT_BYTECODE_VERSION, bytecode_version, 0);
2349 }
2350 void add_extra_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>>> extra_files) {
2351 fbb_.AddOffset(Module::VT_EXTRA_FILES, extra_files);
2352 }
2353 void add_methods(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> methods) {
2354 fbb_.AddOffset(Module::VT_METHODS, methods);
2355 }
2356 void add_state_obj(uint32_t state_obj) {
2357 fbb_.AddElement<uint32_t>(Module::VT_STATE_OBJ, state_obj, 0);
2358 }
2359 void add_ivalues(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>>> ivalues) {
2360 fbb_.AddOffset(Module::VT_IVALUES, ivalues);
2361 }
2362 void add_storage_data_size(int32_t storage_data_size) {
2363 fbb_.AddElement<int32_t>(Module::VT_STORAGE_DATA_SIZE, storage_data_size, 0);
2364 }
2365 void add_storage_data(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>>> storage_data) {
2366 fbb_.AddOffset(Module::VT_STORAGE_DATA, storage_data);
2367 }
2368 void add_object_types(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>>> object_types) {
2369 fbb_.AddOffset(Module::VT_OBJECT_TYPES, object_types);
2370 }
2371 void add_jit_sources(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>>> jit_sources) {
2372 fbb_.AddOffset(Module::VT_JIT_SOURCES, jit_sources);
2373 }
2374 void add_jit_constants(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> jit_constants) {
2375 fbb_.AddOffset(Module::VT_JIT_CONSTANTS, jit_constants);
2376 }
2377 void add_operator_version(uint32_t operator_version) {
2378 fbb_.AddElement<uint32_t>(Module::VT_OPERATOR_VERSION, operator_version, 0);
2379 }
2380 void add_mobile_ivalue_size(uint32_t mobile_ivalue_size) {
2381 fbb_.AddElement<uint32_t>(Module::VT_MOBILE_IVALUE_SIZE, mobile_ivalue_size, 0);
2382 }
2383 explicit ModuleBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
2384 : fbb_(_fbb) {
2385 start_ = fbb_.StartTable();
2386 }
2387 ::flatbuffers::Offset<Module> Finish() {
2388 const auto end = fbb_.EndTable(start_);
2389 auto o = ::flatbuffers::Offset<Module>(end);
2390 return o;
2391 }
2392 };
2393
2394 inline ::flatbuffers::Offset<Module> CreateModule(
2395 ::flatbuffers::FlatBufferBuilder &_fbb,
2396 uint32_t bytecode_version = 0,
2397 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>>> extra_files = 0,
2398 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> methods = 0,
2399 uint32_t state_obj = 0,
2400 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>>> ivalues = 0,
2401 int32_t storage_data_size = 0,
2402 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>>> storage_data = 0,
2403 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>>> object_types = 0,
2404 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>>> jit_sources = 0,
2405 ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> jit_constants = 0,
2406 uint32_t operator_version = 0,
2407 uint32_t mobile_ivalue_size = 0) {
2408 ModuleBuilder builder_(_fbb);
2409 builder_.add_mobile_ivalue_size(mobile_ivalue_size);
2410 builder_.add_operator_version(operator_version);
2411 builder_.add_jit_constants(jit_constants);
2412 builder_.add_jit_sources(jit_sources);
2413 builder_.add_object_types(object_types);
2414 builder_.add_storage_data(storage_data);
2415 builder_.add_storage_data_size(storage_data_size);
2416 builder_.add_ivalues(ivalues);
2417 builder_.add_state_obj(state_obj);
2418 builder_.add_methods(methods);
2419 builder_.add_extra_files(extra_files);
2420 builder_.add_bytecode_version(bytecode_version);
2421 return builder_.Finish();
2422 }
2423
2424 inline ::flatbuffers::Offset<Module> CreateModuleDirect(
2425 ::flatbuffers::FlatBufferBuilder &_fbb,
2426 uint32_t bytecode_version = 0,
2427 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *extra_files = nullptr,
2428 const std::vector<uint32_t> *methods = nullptr,
2429 uint32_t state_obj = 0,
2430 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>> *ivalues = nullptr,
2431 int32_t storage_data_size = 0,
2432 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>> *storage_data = nullptr,
2433 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>> *object_types = nullptr,
2434 const std::vector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>> *jit_sources = nullptr,
2435 const std::vector<uint32_t> *jit_constants = nullptr,
2436 uint32_t operator_version = 0,
2437 uint32_t mobile_ivalue_size = 0) {
2438 auto extra_files__ = extra_files ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>>(*extra_files) : 0;
2439 auto methods__ = methods ? _fbb.CreateVector<uint32_t>(*methods) : 0;
2440 auto ivalues__ = ivalues ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::IValue>>(*ivalues) : 0;
2441 auto storage_data__ = storage_data ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::StorageData>>(*storage_data) : 0;
2442 auto object_types__ = object_types ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::ObjectType>>(*object_types) : 0;
2443 auto jit_sources__ = jit_sources ? _fbb.CreateVector<::flatbuffers::Offset<torch::jit::mobile::serialization::ExtraFile>>(*jit_sources) : 0;
2444 auto jit_constants__ = jit_constants ? _fbb.CreateVector<uint32_t>(*jit_constants) : 0;
2445 return torch::jit::mobile::serialization::CreateModule(
2446 _fbb,
2447 bytecode_version,
2448 extra_files__,
2449 methods__,
2450 state_obj,
2451 ivalues__,
2452 storage_data_size,
2453 storage_data__,
2454 object_types__,
2455 jit_sources__,
2456 jit_constants__,
2457 operator_version,
2458 mobile_ivalue_size);
2459 }
2460
2461 inline bool VerifyIValueUnion(::flatbuffers::Verifier &verifier, const void *obj, IValueUnion type) {
2462 switch (type) {
2463 case IValueUnion::NONE: {
2464 return true;
2465 }
2466 case IValueUnion::Int: {
2467 return verifier.VerifyField<torch::jit::mobile::serialization::Int>(static_cast<const uint8_t *>(obj), 0, 8);
2468 }
2469 case IValueUnion::Bool: {
2470 return verifier.VerifyField<torch::jit::mobile::serialization::Bool>(static_cast<const uint8_t *>(obj), 0, 1);
2471 }
2472 case IValueUnion::Double: {
2473 return verifier.VerifyField<torch::jit::mobile::serialization::Double>(static_cast<const uint8_t *>(obj), 0, 8);
2474 }
2475 case IValueUnion::ComplexDouble: {
2476 return verifier.VerifyField<torch::jit::mobile::serialization::ComplexDouble>(static_cast<const uint8_t *>(obj), 0, 8);
2477 }
2478 case IValueUnion::TensorMetadata: {
2479 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::TensorMetadata *>(obj);
2480 return verifier.VerifyTable(ptr);
2481 }
2482 case IValueUnion::String: {
2483 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::String *>(obj);
2484 return verifier.VerifyTable(ptr);
2485 }
2486 case IValueUnion::List: {
2487 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::List *>(obj);
2488 return verifier.VerifyTable(ptr);
2489 }
2490 case IValueUnion::Tuple: {
2491 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::Tuple *>(obj);
2492 return verifier.VerifyTable(ptr);
2493 }
2494 case IValueUnion::Dict: {
2495 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::Dict *>(obj);
2496 return verifier.VerifyTable(ptr);
2497 }
2498 case IValueUnion::Object: {
2499 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::Object *>(obj);
2500 return verifier.VerifyTable(ptr);
2501 }
2502 case IValueUnion::IntList: {
2503 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::IntList *>(obj);
2504 return verifier.VerifyTable(ptr);
2505 }
2506 case IValueUnion::DoubleList: {
2507 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::DoubleList *>(obj);
2508 return verifier.VerifyTable(ptr);
2509 }
2510 case IValueUnion::BoolList: {
2511 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::BoolList *>(obj);
2512 return verifier.VerifyTable(ptr);
2513 }
2514 case IValueUnion::Device: {
2515 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::Device *>(obj);
2516 return verifier.VerifyTable(ptr);
2517 }
2518 case IValueUnion::EnumValue: {
2519 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::EnumValue *>(obj);
2520 return verifier.VerifyTable(ptr);
2521 }
2522 case IValueUnion::Function: {
2523 auto ptr = reinterpret_cast<const torch::jit::mobile::serialization::Function *>(obj);
2524 return verifier.VerifyTable(ptr);
2525 }
2526 default: return true;
2527 }
2528 }
2529
2530 inline bool VerifyIValueUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<IValueUnion> *types) {
2531 if (!values || !types) return !values && !types;
2532 if (values->size() != types->size()) return false;
2533 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2534 if (!VerifyIValueUnion(
2535 verifier, values->Get(i), types->GetEnum<IValueUnion>(i))) {
2536 return false;
2537 }
2538 }
2539 return true;
2540 }
2541
2542 inline const torch::jit::mobile::serialization::Module *GetModule(const void *buf) {
2543 return ::flatbuffers::GetRoot<torch::jit::mobile::serialization::Module>(buf);
2544 }
2545
2546 inline const torch::jit::mobile::serialization::Module *GetSizePrefixedModule(const void *buf) {
2547 return ::flatbuffers::GetSizePrefixedRoot<torch::jit::mobile::serialization::Module>(buf);
2548 }
2549
2550 inline Module *GetMutableModule(void *buf) {
2551 return ::flatbuffers::GetMutableRoot<Module>(buf);
2552 }
2553
2554 inline torch::jit::mobile::serialization::Module *GetMutableSizePrefixedModule(void *buf) {
2555 return ::flatbuffers::GetMutableSizePrefixedRoot<torch::jit::mobile::serialization::Module>(buf);
2556 }
2557
2558 inline const char *ModuleIdentifier() {
2559 return "PTMF";
2560 }
2561
2562 inline bool ModuleBufferHasIdentifier(const void *buf) {
2563 return ::flatbuffers::BufferHasIdentifier(
2564 buf, ModuleIdentifier());
2565 }
2566
2567 inline bool SizePrefixedModuleBufferHasIdentifier(const void *buf) {
2568 return ::flatbuffers::BufferHasIdentifier(
2569 buf, ModuleIdentifier(), true);
2570 }
2571
2572 inline bool VerifyModuleBuffer(
2573 ::flatbuffers::Verifier &verifier) {
2574 return verifier.VerifyBuffer<torch::jit::mobile::serialization::Module>(ModuleIdentifier());
2575 }
2576
2577 inline bool VerifySizePrefixedModuleBuffer(
2578 ::flatbuffers::Verifier &verifier) {
2579 return verifier.VerifySizePrefixedBuffer<torch::jit::mobile::serialization::Module>(ModuleIdentifier());
2580 }
2581
2582 inline void FinishModuleBuffer(
2583 ::flatbuffers::FlatBufferBuilder &fbb,
2584 ::flatbuffers::Offset<torch::jit::mobile::serialization::Module> root) {
2585 fbb.Finish(root, ModuleIdentifier());
2586 }
2587
2588 inline void FinishSizePrefixedModuleBuffer(
2589 ::flatbuffers::FlatBufferBuilder &fbb,
2590 ::flatbuffers::Offset<torch::jit::mobile::serialization::Module> root) {
2591 fbb.FinishSizePrefixed(root, ModuleIdentifier());
2592 }
2593
2594 } // namespace serialization
2595 } // namespace mobile
2596 } // namespace jit
2597 } // namespace torch
2598
2599 #endif // FLATBUFFERS_GENERATED_MOBILEBYTECODE_TORCH_JIT_MOBILE_SERIALIZATION_H_
2600