Gitiles
Code Review Sign In
review.mlplatform.org / tosa / serialization_lib / 2364dcd7241d730021bf68e000e5a6411b9f09d1 / . / include / tosa_generated.h
blob: 5e883a1ebaebf8fbfe5bf6f7ae827f4a1721d6db [file] [log] [blame]
Eric Kunze2364dcd2021-04-26 11:06:57 -0700[diff] [blame^]1
2// Copyright (c) 2020-2021, ARM Limited.
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16// automatically generated by the FlatBuffers compiler, do not modify
17
18
19#ifndef FLATBUFFERS_GENERATED_TOSA_TOSA_H_
20#define FLATBUFFERS_GENERATED_TOSA_TOSA_H_
21
22#include "flatbuffers/flatbuffers.h"
23
24namespace tosa {
25
26struct Pool2dAttribute;
27struct Pool2dAttributeBuilder;
28
29struct Conv2dAttribute;
30struct Conv2dAttributeBuilder;
31
32struct TransposeConv2dAttribute;
33struct TransposeConv2dAttributeBuilder;
34
35struct ReluNAttribute;
36struct ReluNAttributeBuilder;
37
38struct AxisAttribute;
39struct AxisAttributeBuilder;
40
41struct ReshapeAttribute;
42struct ReshapeAttributeBuilder;
43
44struct SliceAttribute;
45struct SliceAttributeBuilder;
46
47struct TileAttribute;
48struct TileAttributeBuilder;
49
50struct ResizeAttribute;
51struct ResizeAttributeBuilder;
52
53struct ClampAttribute;
54struct ClampAttributeBuilder;
55
56struct RescaleAttribute;
57struct RescaleAttributeBuilder;
58
59struct MulAttribute;
60struct MulAttributeBuilder;
61
62struct ArithmeticRightShiftAttribute;
63struct ArithmeticRightShiftAttributeBuilder;
64
65struct CondIfAttribute;
66struct CondIfAttributeBuilder;
67
68struct WhileLoopAttribute;
69struct WhileLoopAttributeBuilder;
70
71struct UnaryQuantInfo;
72struct UnaryQuantInfoBuilder;
73
74struct ConvQuantInfo;
75struct ConvQuantInfoBuilder;
76
77struct MatMulQuantInfo;
78struct MatMulQuantInfoBuilder;
79
80struct PadQuantInfo;
81struct PadQuantInfoBuilder;
82
83struct Version;
84struct VersionBuilder;
85
86struct TosaTensor;
87struct TosaTensorBuilder;
88
89struct TosaOperator;
90struct TosaOperatorBuilder;
91
92struct TosaBasicBlock;
93struct TosaBasicBlockBuilder;
94
95struct TosaGraph;
96struct TosaGraphBuilder;
97
98enum DType {
99 DType_UNKNOWN = 0,
100 DType_BOOL = 1,
101 DType_UINT8 = 2,
102 DType_INT4 = 3,
103 DType_INT8 = 4,
104 DType_INT16 = 5,
105 DType_INT32 = 6,
106 DType_INT48 = 7,
107 DType_FLOAT = 8,
108 DType_MIN = DType_UNKNOWN,
109 DType_MAX = DType_FLOAT
110};
111
112inline const DType (&EnumValuesDType())[9] {
113 static const DType values[] = {
114 DType_UNKNOWN,
115 DType_BOOL,
116 DType_UINT8,
117 DType_INT4,
118 DType_INT8,
119 DType_INT16,
120 DType_INT32,
121 DType_INT48,
122 DType_FLOAT
123 };
124 return values;
125}
126
127inline const char * const *EnumNamesDType() {
128 static const char * const names[10] = {
129 "UNKNOWN",
130 "BOOL",
131 "UINT8",
132 "INT4",
133 "INT8",
134 "INT16",
135 "INT32",
136 "INT48",
137 "FLOAT",
138 nullptr
139 };
140 return names;
141}
142
143inline const char *EnumNameDType(DType e) {
144 if (flatbuffers::IsOutRange(e, DType_UNKNOWN, DType_FLOAT)) return "";
145 const size_t index = static_cast<size_t>(e);
146 return EnumNamesDType()[index];
147}
148
149enum ResizeMode {
150 ResizeMode_UNKNOWN = 0,
151 ResizeMode_NEAREST = 1,
152 ResizeMode_BILINEAR = 2,
153 ResizeMode_MIN = ResizeMode_UNKNOWN,
154 ResizeMode_MAX = ResizeMode_BILINEAR
155};
156
157inline const ResizeMode (&EnumValuesResizeMode())[3] {
158 static const ResizeMode values[] = {
159 ResizeMode_UNKNOWN,
160 ResizeMode_NEAREST,
161 ResizeMode_BILINEAR
162 };
163 return values;
164}
165
166inline const char * const *EnumNamesResizeMode() {
167 static const char * const names[4] = {
168 "UNKNOWN",
169 "NEAREST",
170 "BILINEAR",
171 nullptr
172 };
173 return names;
174}
175
176inline const char *EnumNameResizeMode(ResizeMode e) {
177 if (flatbuffers::IsOutRange(e, ResizeMode_UNKNOWN, ResizeMode_BILINEAR)) return "";
178 const size_t index = static_cast<size_t>(e);
179 return EnumNamesResizeMode()[index];
180}
181
182enum Op {
183 Op_UNKNOWN = 0,
184 Op_ARGMAX = 1,
185 Op_AVG_POOL2D = 2,
186 Op_CONV2D = 3,
187 Op_CONV3D = 4,
188 Op_DEPTHWISE_CONV2D = 5,
189 Op_FULLY_CONNECTED = 6,
190 Op_MATMUL = 7,
191 Op_MAX_POOL2D = 8,
192 Op_TRANSPOSE_CONV2D = 9,
193 Op_CLAMP = 10,
194 Op_RELUN = 11,
195 Op_SIGMOID = 12,
196 Op_TANH = 13,
197 Op_ADD = 14,
198 Op_ARITHMETIC_RIGHT_SHIFT = 15,
199 Op_BITWISE_AND = 16,
200 Op_BITWISE_OR = 17,
201 Op_BITWISE_XOR = 18,
202 Op_LOGICAL_AND = 19,
203 Op_LOGICAL_LEFT_SHIFT = 20,
204 Op_LOGICAL_RIGHT_SHIFT = 21,
205 Op_LOGICAL_OR = 22,
206 Op_LOGICAL_XOR = 23,
207 Op_MAXIMUM = 24,
208 Op_MINIMUM = 25,
209 Op_MUL = 26,
210 Op_POW = 27,
211 Op_SUB = 28,
212 Op_TABLE = 29,
213 Op_ABS = 30,
214 Op_BITWISE_NOT = 31,
215 Op_CEIL = 32,
216 Op_CLZ = 33,
217 Op_EXP = 34,
218 Op_FLOOR = 35,
219 Op_LOG = 36,
220 Op_LOGICAL_NOT = 37,
221 Op_NEGATE = 38,
222 Op_RECIPROCAL = 39,
223 Op_RSQRT = 40,
224 Op_SELECT = 41,
225 Op_EQUAL = 42,
226 Op_GREATER = 43,
227 Op_GREATER_EQUAL = 44,
228 Op_REDUCE_ANY = 45,
229 Op_REDUCE_ALL = 46,
230 Op_REDUCE_MAX = 47,
231 Op_REDUCE_MIN = 48,
232 Op_REDUCE_PRODUCT = 49,
233 Op_REDUCE_SUM = 50,
234 Op_CONCAT = 51,
235 Op_PAD = 52,
236 Op_RESHAPE = 53,
237 Op_REVERSE = 54,
238 Op_SLICE = 55,
239 Op_TILE = 56,
240 Op_TRANSPOSE = 57,
241 Op_GATHER = 58,
242 Op_SCATTER = 59,
243 Op_RESIZE = 60,
244 Op_CAST = 61,
245 Op_RESCALE = 62,
246 Op_CONST = 63,
247 Op_PLACEHOLDER = 64,
248 Op_IDENTITY = 65,
249 Op_IDENTITYN = 66,
250 Op_CUSTOM = 67,
251 Op_COND_IF = 68,
252 Op_WHILE_LOOP = 69,
253 Op_MIN = Op_UNKNOWN,
254 Op_MAX = Op_WHILE_LOOP
255};
256
257inline const Op (&EnumValuesOp())[70] {
258 static const Op values[] = {
259 Op_UNKNOWN,
260 Op_ARGMAX,
261 Op_AVG_POOL2D,
262 Op_CONV2D,
263 Op_CONV3D,
264 Op_DEPTHWISE_CONV2D,
265 Op_FULLY_CONNECTED,
266 Op_MATMUL,
267 Op_MAX_POOL2D,
268 Op_TRANSPOSE_CONV2D,
269 Op_CLAMP,
270 Op_RELUN,
271 Op_SIGMOID,
272 Op_TANH,
273 Op_ADD,
274 Op_ARITHMETIC_RIGHT_SHIFT,
275 Op_BITWISE_AND,
276 Op_BITWISE_OR,
277 Op_BITWISE_XOR,
278 Op_LOGICAL_AND,
279 Op_LOGICAL_LEFT_SHIFT,
280 Op_LOGICAL_RIGHT_SHIFT,
281 Op_LOGICAL_OR,
282 Op_LOGICAL_XOR,
283 Op_MAXIMUM,
284 Op_MINIMUM,
285 Op_MUL,
286 Op_POW,
287 Op_SUB,
288 Op_TABLE,
289 Op_ABS,
290 Op_BITWISE_NOT,
291 Op_CEIL,
292 Op_CLZ,
293 Op_EXP,
294 Op_FLOOR,
295 Op_LOG,
296 Op_LOGICAL_NOT,
297 Op_NEGATE,
298 Op_RECIPROCAL,
299 Op_RSQRT,
300 Op_SELECT,
301 Op_EQUAL,
302 Op_GREATER,
303 Op_GREATER_EQUAL,
304 Op_REDUCE_ANY,
305 Op_REDUCE_ALL,
306 Op_REDUCE_MAX,
307 Op_REDUCE_MIN,
308 Op_REDUCE_PRODUCT,
309 Op_REDUCE_SUM,
310 Op_CONCAT,
311 Op_PAD,
312 Op_RESHAPE,
313 Op_REVERSE,
314 Op_SLICE,
315 Op_TILE,
316 Op_TRANSPOSE,
317 Op_GATHER,
318 Op_SCATTER,
319 Op_RESIZE,
320 Op_CAST,
321 Op_RESCALE,
322 Op_CONST,
323 Op_PLACEHOLDER,
324 Op_IDENTITY,
325 Op_IDENTITYN,
326 Op_CUSTOM,
327 Op_COND_IF,
328 Op_WHILE_LOOP
329 };
330 return values;
331}
332
333inline const char * const *EnumNamesOp() {
334 static const char * const names[71] = {
335 "UNKNOWN",
336 "ARGMAX",
337 "AVG_POOL2D",
338 "CONV2D",
339 "CONV3D",
340 "DEPTHWISE_CONV2D",
341 "FULLY_CONNECTED",
342 "MATMUL",
343 "MAX_POOL2D",
344 "TRANSPOSE_CONV2D",
345 "CLAMP",
346 "RELUN",
347 "SIGMOID",
348 "TANH",
349 "ADD",
350 "ARITHMETIC_RIGHT_SHIFT",
351 "BITWISE_AND",
352 "BITWISE_OR",
353 "BITWISE_XOR",
354 "LOGICAL_AND",
355 "LOGICAL_LEFT_SHIFT",
356 "LOGICAL_RIGHT_SHIFT",
357 "LOGICAL_OR",
358 "LOGICAL_XOR",
359 "MAXIMUM",
360 "MINIMUM",
361 "MUL",
362 "POW",
363 "SUB",
364 "TABLE",
365 "ABS",
366 "BITWISE_NOT",
367 "CEIL",
368 "CLZ",
369 "EXP",
370 "FLOOR",
371 "LOG",
372 "LOGICAL_NOT",
373 "NEGATE",
374 "RECIPROCAL",
375 "RSQRT",
376 "SELECT",
377 "EQUAL",
378 "GREATER",
379 "GREATER_EQUAL",
380 "REDUCE_ANY",
381 "REDUCE_ALL",
382 "REDUCE_MAX",
383 "REDUCE_MIN",
384 "REDUCE_PRODUCT",
385 "REDUCE_SUM",
386 "CONCAT",
387 "PAD",
388 "RESHAPE",
389 "REVERSE",
390 "SLICE",
391 "TILE",
392 "TRANSPOSE",
393 "GATHER",
394 "SCATTER",
395 "RESIZE",
396 "CAST",
397 "RESCALE",
398 "CONST",
399 "PLACEHOLDER",
400 "IDENTITY",
401 "IDENTITYN",
402 "CUSTOM",
403 "COND_IF",
404 "WHILE_LOOP",
405 nullptr
406 };
407 return names;
408}
409
410inline const char *EnumNameOp(Op e) {
411 if (flatbuffers::IsOutRange(e, Op_UNKNOWN, Op_WHILE_LOOP)) return "";
412 const size_t index = static_cast<size_t>(e);
413 return EnumNamesOp()[index];
414}
415
416enum Attribute {
417 Attribute_NONE = 0,
418 Attribute_Pool2dAttribute = 1,
419 Attribute_Conv2dAttribute = 2,
420 Attribute_TransposeConv2dAttribute = 3,
421 Attribute_ReluNAttribute = 4,
422 Attribute_AxisAttribute = 5,
423 Attribute_ReshapeAttribute = 6,
424 Attribute_SliceAttribute = 7,
425 Attribute_TileAttribute = 8,
426 Attribute_ResizeAttribute = 9,
427 Attribute_ClampAttribute = 10,
428 Attribute_RescaleAttribute = 11,
429 Attribute_MulAttribute = 12,
430 Attribute_ArithmeticRightShiftAttribute = 13,
431 Attribute_CondIfAttribute = 14,
432 Attribute_WhileLoopAttribute = 15,
433 Attribute_MIN = Attribute_NONE,
434 Attribute_MAX = Attribute_WhileLoopAttribute
435};
436
437inline const Attribute (&EnumValuesAttribute())[16] {
438 static const Attribute values[] = {
439 Attribute_NONE,
440 Attribute_Pool2dAttribute,
441 Attribute_Conv2dAttribute,
442 Attribute_TransposeConv2dAttribute,
443 Attribute_ReluNAttribute,
444 Attribute_AxisAttribute,
445 Attribute_ReshapeAttribute,
446 Attribute_SliceAttribute,
447 Attribute_TileAttribute,
448 Attribute_ResizeAttribute,
449 Attribute_ClampAttribute,
450 Attribute_RescaleAttribute,
451 Attribute_MulAttribute,
452 Attribute_ArithmeticRightShiftAttribute,
453 Attribute_CondIfAttribute,
454 Attribute_WhileLoopAttribute
455 };
456 return values;
457}
458
459inline const char * const *EnumNamesAttribute() {
460 static const char * const names[17] = {
461 "NONE",
462 "Pool2dAttribute",
463 "Conv2dAttribute",
464 "TransposeConv2dAttribute",
465 "ReluNAttribute",
466 "AxisAttribute",
467 "ReshapeAttribute",
468 "SliceAttribute",
469 "TileAttribute",
470 "ResizeAttribute",
471 "ClampAttribute",
472 "RescaleAttribute",
473 "MulAttribute",
474 "ArithmeticRightShiftAttribute",
475 "CondIfAttribute",
476 "WhileLoopAttribute",
477 nullptr
478 };
479 return names;
480}
481
482inline const char *EnumNameAttribute(Attribute e) {
483 if (flatbuffers::IsOutRange(e, Attribute_NONE, Attribute_WhileLoopAttribute)) return "";
484 const size_t index = static_cast<size_t>(e);
485 return EnumNamesAttribute()[index];
486}
487
488template<typename T> struct AttributeTraits {
489 static const Attribute enum_value = Attribute_NONE;
490};
491
492template<> struct AttributeTraits<tosa::Pool2dAttribute> {
493 static const Attribute enum_value = Attribute_Pool2dAttribute;
494};
495
496template<> struct AttributeTraits<tosa::Conv2dAttribute> {
497 static const Attribute enum_value = Attribute_Conv2dAttribute;
498};
499
500template<> struct AttributeTraits<tosa::TransposeConv2dAttribute> {
501 static const Attribute enum_value = Attribute_TransposeConv2dAttribute;
502};
503
504template<> struct AttributeTraits<tosa::ReluNAttribute> {
505 static const Attribute enum_value = Attribute_ReluNAttribute;
506};
507
508template<> struct AttributeTraits<tosa::AxisAttribute> {
509 static const Attribute enum_value = Attribute_AxisAttribute;
510};
511
512template<> struct AttributeTraits<tosa::ReshapeAttribute> {
513 static const Attribute enum_value = Attribute_ReshapeAttribute;
514};
515
516template<> struct AttributeTraits<tosa::SliceAttribute> {
517 static const Attribute enum_value = Attribute_SliceAttribute;
518};
519
520template<> struct AttributeTraits<tosa::TileAttribute> {
521 static const Attribute enum_value = Attribute_TileAttribute;
522};
523
524template<> struct AttributeTraits<tosa::ResizeAttribute> {
525 static const Attribute enum_value = Attribute_ResizeAttribute;
526};
527
528template<> struct AttributeTraits<tosa::ClampAttribute> {
529 static const Attribute enum_value = Attribute_ClampAttribute;
530};
531
532template<> struct AttributeTraits<tosa::RescaleAttribute> {
533 static const Attribute enum_value = Attribute_RescaleAttribute;
534};
535
536template<> struct AttributeTraits<tosa::MulAttribute> {
537 static const Attribute enum_value = Attribute_MulAttribute;
538};
539
540template<> struct AttributeTraits<tosa::ArithmeticRightShiftAttribute> {
541 static const Attribute enum_value = Attribute_ArithmeticRightShiftAttribute;
542};
543
544template<> struct AttributeTraits<tosa::CondIfAttribute> {
545 static const Attribute enum_value = Attribute_CondIfAttribute;
546};
547
548template<> struct AttributeTraits<tosa::WhileLoopAttribute> {
549 static const Attribute enum_value = Attribute_WhileLoopAttribute;
550};
551
552bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type);
553bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
554
555enum QuantInfo {
556 QuantInfo_NONE = 0,
557 QuantInfo_UnaryQuantInfo = 1,
558 QuantInfo_ConvQuantInfo = 2,
559 QuantInfo_MatMulQuantInfo = 3,
560 QuantInfo_PadQuantInfo = 4,
561 QuantInfo_MIN = QuantInfo_NONE,
562 QuantInfo_MAX = QuantInfo_PadQuantInfo
563};
564
565inline const QuantInfo (&EnumValuesQuantInfo())[5] {
566 static const QuantInfo values[] = {
567 QuantInfo_NONE,
568 QuantInfo_UnaryQuantInfo,
569 QuantInfo_ConvQuantInfo,
570 QuantInfo_MatMulQuantInfo,
571 QuantInfo_PadQuantInfo
572 };
573 return values;
574}
575
576inline const char * const *EnumNamesQuantInfo() {
577 static const char * const names[6] = {
578 "NONE",
579 "UnaryQuantInfo",
580 "ConvQuantInfo",
581 "MatMulQuantInfo",
582 "PadQuantInfo",
583 nullptr
584 };
585 return names;
586}
587
588inline const char *EnumNameQuantInfo(QuantInfo e) {
589 if (flatbuffers::IsOutRange(e, QuantInfo_NONE, QuantInfo_PadQuantInfo)) return "";
590 const size_t index = static_cast<size_t>(e);
591 return EnumNamesQuantInfo()[index];
592}
593
594template<typename T> struct QuantInfoTraits {
595 static const QuantInfo enum_value = QuantInfo_NONE;
596};
597
598template<> struct QuantInfoTraits<tosa::UnaryQuantInfo> {
599 static const QuantInfo enum_value = QuantInfo_UnaryQuantInfo;
600};
601
602template<> struct QuantInfoTraits<tosa::ConvQuantInfo> {
603 static const QuantInfo enum_value = QuantInfo_ConvQuantInfo;
604};
605
606template<> struct QuantInfoTraits<tosa::MatMulQuantInfo> {
607 static const QuantInfo enum_value = QuantInfo_MatMulQuantInfo;
608};
609
610template<> struct QuantInfoTraits<tosa::PadQuantInfo> {
611 static const QuantInfo enum_value = QuantInfo_PadQuantInfo;
612};
613
614bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type);
615bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
616
617struct Pool2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
618 typedef Pool2dAttributeBuilder Builder;
619 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
620 VT_PADDING = 4,
621 VT_KERNEL = 6,
622 VT_STRIDE = 8
623 };
624 const flatbuffers::Vector<int32_t> *padding() const {
625 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING);
626 }
627 const flatbuffers::Vector<int32_t> *kernel() const {
628 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_KERNEL);
629 }
630 const flatbuffers::Vector<int32_t> *stride() const {
631 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
632 }
633 bool Verify(flatbuffers::Verifier &verifier) const {
634 return VerifyTableStart(verifier) &&
635 VerifyOffset(verifier, VT_PADDING) &&
636 verifier.VerifyVector(padding()) &&
637 VerifyOffset(verifier, VT_KERNEL) &&
638 verifier.VerifyVector(kernel()) &&
639 VerifyOffset(verifier, VT_STRIDE) &&
640 verifier.VerifyVector(stride()) &&
641 verifier.EndTable();
642 }
643};
644
645struct Pool2dAttributeBuilder {
646 typedef Pool2dAttribute Table;
647 flatbuffers::FlatBufferBuilder &fbb_;
648 flatbuffers::uoffset_t start_;
649 void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) {
650 fbb_.AddOffset(Pool2dAttribute::VT_PADDING, padding);
651 }
652 void add_kernel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel) {
653 fbb_.AddOffset(Pool2dAttribute::VT_KERNEL, kernel);
654 }
655 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
656 fbb_.AddOffset(Pool2dAttribute::VT_STRIDE, stride);
657 }
658 explicit Pool2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
659 : fbb_(_fbb) {
660 start_ = fbb_.StartTable();
661 }
662 Pool2dAttributeBuilder &operator=(const Pool2dAttributeBuilder &);
663 flatbuffers::Offset<Pool2dAttribute> Finish() {
664 const auto end = fbb_.EndTable(start_);
665 auto o = flatbuffers::Offset<Pool2dAttribute>(end);
666 return o;
667 }
668};
669
670inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttribute(
671 flatbuffers::FlatBufferBuilder &_fbb,
672 flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0,
673 flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel = 0,
674 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0) {
675 Pool2dAttributeBuilder builder_(_fbb);
676 builder_.add_stride(stride);
677 builder_.add_kernel(kernel);
678 builder_.add_padding(padding);
679 return builder_.Finish();
680}
681
682inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttributeDirect(
683 flatbuffers::FlatBufferBuilder &_fbb,
684 const std::vector<int32_t> *padding = nullptr,
685 const std::vector<int32_t> *kernel = nullptr,
686 const std::vector<int32_t> *stride = nullptr) {
687 auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
688 auto kernel__ = kernel ? _fbb.CreateVector<int32_t>(*kernel) : 0;
689 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
690 return tosa::CreatePool2dAttribute(
691 _fbb,
692 padding__,
693 kernel__,
694 stride__);
695}
696
697struct Conv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
698 typedef Conv2dAttributeBuilder Builder;
699 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
700 VT_PADDING = 4,
701 VT_STRIDE = 6,
702 VT_DILATION = 8
703 };
704 const flatbuffers::Vector<int32_t> *padding() const {
705 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING);
706 }
707 const flatbuffers::Vector<int32_t> *stride() const {
708 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
709 }
710 const flatbuffers::Vector<int32_t> *dilation() const {
711 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION);
712 }
713 bool Verify(flatbuffers::Verifier &verifier) const {
714 return VerifyTableStart(verifier) &&
715 VerifyOffset(verifier, VT_PADDING) &&
716 verifier.VerifyVector(padding()) &&
717 VerifyOffset(verifier, VT_STRIDE) &&
718 verifier.VerifyVector(stride()) &&
719 VerifyOffset(verifier, VT_DILATION) &&
720 verifier.VerifyVector(dilation()) &&
721 verifier.EndTable();
722 }
723};
724
725struct Conv2dAttributeBuilder {
726 typedef Conv2dAttribute Table;
727 flatbuffers::FlatBufferBuilder &fbb_;
728 flatbuffers::uoffset_t start_;
729 void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) {
730 fbb_.AddOffset(Conv2dAttribute::VT_PADDING, padding);
731 }
732 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
733 fbb_.AddOffset(Conv2dAttribute::VT_STRIDE, stride);
734 }
735 void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) {
736 fbb_.AddOffset(Conv2dAttribute::VT_DILATION, dilation);
737 }
738 explicit Conv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
739 : fbb_(_fbb) {
740 start_ = fbb_.StartTable();
741 }
742 Conv2dAttributeBuilder &operator=(const Conv2dAttributeBuilder &);
743 flatbuffers::Offset<Conv2dAttribute> Finish() {
744 const auto end = fbb_.EndTable(start_);
745 auto o = flatbuffers::Offset<Conv2dAttribute>(end);
746 return o;
747 }
748};
749
750inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttribute(
751 flatbuffers::FlatBufferBuilder &_fbb,
752 flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0,
753 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0,
754 flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0) {
755 Conv2dAttributeBuilder builder_(_fbb);
756 builder_.add_dilation(dilation);
757 builder_.add_stride(stride);
758 builder_.add_padding(padding);
759 return builder_.Finish();
760}
761
762inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttributeDirect(
763 flatbuffers::FlatBufferBuilder &_fbb,
764 const std::vector<int32_t> *padding = nullptr,
765 const std::vector<int32_t> *stride = nullptr,
766 const std::vector<int32_t> *dilation = nullptr) {
767 auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
768 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
769 auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
770 return tosa::CreateConv2dAttribute(
771 _fbb,
772 padding__,
773 stride__,
774 dilation__);
775}
776
777struct TransposeConv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
778 typedef TransposeConv2dAttributeBuilder Builder;
779 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
780 VT_OUTPAD = 4,
781 VT_STRIDE = 6,
782 VT_DILATION = 8,
783 VT_OUTPUT_SHAPE = 10
784 };
785 const flatbuffers::Vector<int32_t> *outpad() const {
786 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPAD);
787 }
788 const flatbuffers::Vector<int32_t> *stride() const {
789 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
790 }
791 const flatbuffers::Vector<int32_t> *dilation() const {
792 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION);
793 }
794 const flatbuffers::Vector<int32_t> *output_shape() const {
795 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SHAPE);
796 }
797 bool Verify(flatbuffers::Verifier &verifier) const {
798 return VerifyTableStart(verifier) &&
799 VerifyOffset(verifier, VT_OUTPAD) &&
800 verifier.VerifyVector(outpad()) &&
801 VerifyOffset(verifier, VT_STRIDE) &&
802 verifier.VerifyVector(stride()) &&
803 VerifyOffset(verifier, VT_DILATION) &&
804 verifier.VerifyVector(dilation()) &&
805 VerifyOffset(verifier, VT_OUTPUT_SHAPE) &&
806 verifier.VerifyVector(output_shape()) &&
807 verifier.EndTable();
808 }
809};
810
811struct TransposeConv2dAttributeBuilder {
812 typedef TransposeConv2dAttribute Table;
813 flatbuffers::FlatBufferBuilder &fbb_;
814 flatbuffers::uoffset_t start_;
815 void add_outpad(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad) {
816 fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPAD, outpad);
817 }
818 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
819 fbb_.AddOffset(TransposeConv2dAttribute::VT_STRIDE, stride);
820 }
821 void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) {
822 fbb_.AddOffset(TransposeConv2dAttribute::VT_DILATION, dilation);
823 }
824 void add_output_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape) {
825 fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPUT_SHAPE, output_shape);
826 }
827 explicit TransposeConv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
828 : fbb_(_fbb) {
829 start_ = fbb_.StartTable();
830 }
831 TransposeConv2dAttributeBuilder &operator=(const TransposeConv2dAttributeBuilder &);
832 flatbuffers::Offset<TransposeConv2dAttribute> Finish() {
833 const auto end = fbb_.EndTable(start_);
834 auto o = flatbuffers::Offset<TransposeConv2dAttribute>(end);
835 return o;
836 }
837};
838
839inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttribute(
840 flatbuffers::FlatBufferBuilder &_fbb,
841 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad = 0,
842 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0,
843 flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0,
844 flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape = 0) {
845 TransposeConv2dAttributeBuilder builder_(_fbb);
846 builder_.add_output_shape(output_shape);
847 builder_.add_dilation(dilation);
848 builder_.add_stride(stride);
849 builder_.add_outpad(outpad);
850 return builder_.Finish();
851}
852
853inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttributeDirect(
854 flatbuffers::FlatBufferBuilder &_fbb,
855 const std::vector<int32_t> *outpad = nullptr,
856 const std::vector<int32_t> *stride = nullptr,
857 const std::vector<int32_t> *dilation = nullptr,
858 const std::vector<int32_t> *output_shape = nullptr) {
859 auto outpad__ = outpad ? _fbb.CreateVector<int32_t>(*outpad) : 0;
860 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
861 auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
862 auto output_shape__ = output_shape ? _fbb.CreateVector<int32_t>(*output_shape) : 0;
863 return tosa::CreateTransposeConv2dAttribute(
864 _fbb,
865 outpad__,
866 stride__,
867 dilation__,
868 output_shape__);
869}
870
871struct ReluNAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
872 typedef ReluNAttributeBuilder Builder;
873 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
874 VT_MAX_INT = 4,
875 VT_MAX_FP = 6
876 };
877 int32_t max_int() const {
878 return GetField<int32_t>(VT_MAX_INT, 0);
879 }
880 float max_fp() const {
881 return GetField<float>(VT_MAX_FP, 0.0f);
882 }
883 bool Verify(flatbuffers::Verifier &verifier) const {
884 return VerifyTableStart(verifier) &&
885 VerifyField<int32_t>(verifier, VT_MAX_INT) &&
886 VerifyField<float>(verifier, VT_MAX_FP) &&
887 verifier.EndTable();
888 }
889};
890
891struct ReluNAttributeBuilder {
892 typedef ReluNAttribute Table;
893 flatbuffers::FlatBufferBuilder &fbb_;
894 flatbuffers::uoffset_t start_;
895 void add_max_int(int32_t max_int) {
896 fbb_.AddElement<int32_t>(ReluNAttribute::VT_MAX_INT, max_int, 0);
897 }
898 void add_max_fp(float max_fp) {
899 fbb_.AddElement<float>(ReluNAttribute::VT_MAX_FP, max_fp, 0.0f);
900 }
901 explicit ReluNAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
902 : fbb_(_fbb) {
903 start_ = fbb_.StartTable();
904 }
905 ReluNAttributeBuilder &operator=(const ReluNAttributeBuilder &);
906 flatbuffers::Offset<ReluNAttribute> Finish() {
907 const auto end = fbb_.EndTable(start_);
908 auto o = flatbuffers::Offset<ReluNAttribute>(end);
909 return o;
910 }
911};
912
913inline flatbuffers::Offset<ReluNAttribute> CreateReluNAttribute(
914 flatbuffers::FlatBufferBuilder &_fbb,
915 int32_t max_int = 0,
916 float max_fp = 0.0f) {
917 ReluNAttributeBuilder builder_(_fbb);
918 builder_.add_max_fp(max_fp);
919 builder_.add_max_int(max_int);
920 return builder_.Finish();
921}
922
923struct AxisAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
924 typedef AxisAttributeBuilder Builder;
925 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
926 VT_AXIS = 4
927 };
928 int32_t axis() const {
929 return GetField<int32_t>(VT_AXIS, 0);
930 }
931 bool Verify(flatbuffers::Verifier &verifier) const {
932 return VerifyTableStart(verifier) &&
933 VerifyField<int32_t>(verifier, VT_AXIS) &&
934 verifier.EndTable();
935 }
936};
937
938struct AxisAttributeBuilder {
939 typedef AxisAttribute Table;
940 flatbuffers::FlatBufferBuilder &fbb_;
941 flatbuffers::uoffset_t start_;
942 void add_axis(int32_t axis) {
943 fbb_.AddElement<int32_t>(AxisAttribute::VT_AXIS, axis, 0);
944 }
945 explicit AxisAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
946 : fbb_(_fbb) {
947 start_ = fbb_.StartTable();
948 }
949 AxisAttributeBuilder &operator=(const AxisAttributeBuilder &);
950 flatbuffers::Offset<AxisAttribute> Finish() {
951 const auto end = fbb_.EndTable(start_);
952 auto o = flatbuffers::Offset<AxisAttribute>(end);
953 return o;
954 }
955};
956
957inline flatbuffers::Offset<AxisAttribute> CreateAxisAttribute(
958 flatbuffers::FlatBufferBuilder &_fbb,
959 int32_t axis = 0) {
960 AxisAttributeBuilder builder_(_fbb);
961 builder_.add_axis(axis);
962 return builder_.Finish();
963}
964
965struct ReshapeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
966 typedef ReshapeAttributeBuilder Builder;
967 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
968 VT_SHAPE = 4
969 };
970 const flatbuffers::Vector<int32_t> *shape() const {
971 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
972 }
973 bool Verify(flatbuffers::Verifier &verifier) const {
974 return VerifyTableStart(verifier) &&
975 VerifyOffset(verifier, VT_SHAPE) &&
976 verifier.VerifyVector(shape()) &&
977 verifier.EndTable();
978 }
979};
980
981struct ReshapeAttributeBuilder {
982 typedef ReshapeAttribute Table;
983 flatbuffers::FlatBufferBuilder &fbb_;
984 flatbuffers::uoffset_t start_;
985 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
986 fbb_.AddOffset(ReshapeAttribute::VT_SHAPE, shape);
987 }
988 explicit ReshapeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
989 : fbb_(_fbb) {
990 start_ = fbb_.StartTable();
991 }
992 ReshapeAttributeBuilder &operator=(const ReshapeAttributeBuilder &);
993 flatbuffers::Offset<ReshapeAttribute> Finish() {
994 const auto end = fbb_.EndTable(start_);
995 auto o = flatbuffers::Offset<ReshapeAttribute>(end);
996 return o;
997 }
998};
999
1000inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttribute(
1001 flatbuffers::FlatBufferBuilder &_fbb,
1002 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0) {
1003 ReshapeAttributeBuilder builder_(_fbb);
1004 builder_.add_shape(shape);
1005 return builder_.Finish();
1006}
1007
1008inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttributeDirect(
1009 flatbuffers::FlatBufferBuilder &_fbb,
1010 const std::vector<int32_t> *shape = nullptr) {
1011 auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
1012 return tosa::CreateReshapeAttribute(
1013 _fbb,
1014 shape__);
1015}
1016
1017struct SliceAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1018 typedef SliceAttributeBuilder Builder;
1019 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1020 VT_BEGIN = 4,
1021 VT_SIZE = 6
1022 };
1023 const flatbuffers::Vector<int32_t> *begin() const {
1024 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BEGIN);
1025 }
1026 const flatbuffers::Vector<int32_t> *size() const {
1027 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SIZE);
1028 }
1029 bool Verify(flatbuffers::Verifier &verifier) const {
1030 return VerifyTableStart(verifier) &&
1031 VerifyOffset(verifier, VT_BEGIN) &&
1032 verifier.VerifyVector(begin()) &&
1033 VerifyOffset(verifier, VT_SIZE) &&
1034 verifier.VerifyVector(size()) &&
1035 verifier.EndTable();
1036 }
1037};
1038
1039struct SliceAttributeBuilder {
1040 typedef SliceAttribute Table;
1041 flatbuffers::FlatBufferBuilder &fbb_;
1042 flatbuffers::uoffset_t start_;
1043 void add_begin(flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin) {
1044 fbb_.AddOffset(SliceAttribute::VT_BEGIN, begin);
1045 }
1046 void add_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> size) {
1047 fbb_.AddOffset(SliceAttribute::VT_SIZE, size);
1048 }
1049 explicit SliceAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1050 : fbb_(_fbb) {
1051 start_ = fbb_.StartTable();
1052 }
1053 SliceAttributeBuilder &operator=(const SliceAttributeBuilder &);
1054 flatbuffers::Offset<SliceAttribute> Finish() {
1055 const auto end = fbb_.EndTable(start_);
1056 auto o = flatbuffers::Offset<SliceAttribute>(end);
1057 return o;
1058 }
1059};
1060
1061inline flatbuffers::Offset<SliceAttribute> CreateSliceAttribute(
1062 flatbuffers::FlatBufferBuilder &_fbb,
1063 flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin = 0,
1064 flatbuffers::Offset<flatbuffers::Vector<int32_t>> size = 0) {
1065 SliceAttributeBuilder builder_(_fbb);
1066 builder_.add_size(size);
1067 builder_.add_begin(begin);
1068 return builder_.Finish();
1069}
1070
1071inline flatbuffers::Offset<SliceAttribute> CreateSliceAttributeDirect(
1072 flatbuffers::FlatBufferBuilder &_fbb,
1073 const std::vector<int32_t> *begin = nullptr,
1074 const std::vector<int32_t> *size = nullptr) {
1075 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
1076 auto size__ = size ? _fbb.CreateVector<int32_t>(*size) : 0;
1077 return tosa::CreateSliceAttribute(
1078 _fbb,
1079 begin__,
1080 size__);
1081}
1082
1083struct TileAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1084 typedef TileAttributeBuilder Builder;
1085 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1086 VT_MULTIPLES = 4
1087 };
1088 const flatbuffers::Vector<int32_t> *multiples() const {
1089 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLES);
1090 }
1091 bool Verify(flatbuffers::Verifier &verifier) const {
1092 return VerifyTableStart(verifier) &&
1093 VerifyOffset(verifier, VT_MULTIPLES) &&
1094 verifier.VerifyVector(multiples()) &&
1095 verifier.EndTable();
1096 }
1097};
1098
1099struct TileAttributeBuilder {
1100 typedef TileAttribute Table;
1101 flatbuffers::FlatBufferBuilder &fbb_;
1102 flatbuffers::uoffset_t start_;
1103 void add_multiples(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples) {
1104 fbb_.AddOffset(TileAttribute::VT_MULTIPLES, multiples);
1105 }
1106 explicit TileAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1107 : fbb_(_fbb) {
1108 start_ = fbb_.StartTable();
1109 }
1110 TileAttributeBuilder &operator=(const TileAttributeBuilder &);
1111 flatbuffers::Offset<TileAttribute> Finish() {
1112 const auto end = fbb_.EndTable(start_);
1113 auto o = flatbuffers::Offset<TileAttribute>(end);
1114 return o;
1115 }
1116};
1117
1118inline flatbuffers::Offset<TileAttribute> CreateTileAttribute(
1119 flatbuffers::FlatBufferBuilder &_fbb,
1120 flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples = 0) {
1121 TileAttributeBuilder builder_(_fbb);
1122 builder_.add_multiples(multiples);
1123 return builder_.Finish();
1124}
1125
1126inline flatbuffers::Offset<TileAttribute> CreateTileAttributeDirect(
1127 flatbuffers::FlatBufferBuilder &_fbb,
1128 const std::vector<int32_t> *multiples = nullptr) {
1129 auto multiples__ = multiples ? _fbb.CreateVector<int32_t>(*multiples) : 0;
1130 return tosa::CreateTileAttribute(
1131 _fbb,
1132 multiples__);
1133}
1134
1135struct ResizeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1136 typedef ResizeAttributeBuilder Builder;
1137 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1138 VT_OUTPUT_SIZE = 4,
1139 VT_STRIDE = 6,
1140 VT_OFFSET = 8,
1141 VT_SHIFT = 10,
1142 VT_STRIDE_FP = 12,
1143 VT_OFFSET_FP = 14,
1144 VT_MODE = 16
1145 };
1146 const flatbuffers::Vector<int32_t> *output_size() const {
1147 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SIZE);
1148 }
1149 const flatbuffers::Vector<int32_t> *stride() const {
1150 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
1151 }
1152 const flatbuffers::Vector<int32_t> *offset() const {
1153 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OFFSET);
1154 }
1155 int32_t shift() const {
1156 return GetField<int32_t>(VT_SHIFT, 0);
1157 }
1158 const flatbuffers::Vector<float> *stride_fp() const {
1159 return GetPointer<const flatbuffers::Vector<float> *>(VT_STRIDE_FP);
1160 }
1161 const flatbuffers::Vector<float> *offset_fp() const {
1162 return GetPointer<const flatbuffers::Vector<float> *>(VT_OFFSET_FP);
1163 }
1164 tosa::ResizeMode mode() const {
1165 return static_cast<tosa::ResizeMode>(GetField<uint32_t>(VT_MODE, 0));
1166 }
1167 bool Verify(flatbuffers::Verifier &verifier) const {
1168 return VerifyTableStart(verifier) &&
1169 VerifyOffset(verifier, VT_OUTPUT_SIZE) &&
1170 verifier.VerifyVector(output_size()) &&
1171 VerifyOffset(verifier, VT_STRIDE) &&
1172 verifier.VerifyVector(stride()) &&
1173 VerifyOffset(verifier, VT_OFFSET) &&
1174 verifier.VerifyVector(offset()) &&
1175 VerifyField<int32_t>(verifier, VT_SHIFT) &&
1176 VerifyOffset(verifier, VT_STRIDE_FP) &&
1177 verifier.VerifyVector(stride_fp()) &&
1178 VerifyOffset(verifier, VT_OFFSET_FP) &&
1179 verifier.VerifyVector(offset_fp()) &&
1180 VerifyField<uint32_t>(verifier, VT_MODE) &&
1181 verifier.EndTable();
1182 }
1183};
1184
1185struct ResizeAttributeBuilder {
1186 typedef ResizeAttribute Table;
1187 flatbuffers::FlatBufferBuilder &fbb_;
1188 flatbuffers::uoffset_t start_;
1189 void add_output_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size) {
1190 fbb_.AddOffset(ResizeAttribute::VT_OUTPUT_SIZE, output_size);
1191 }
1192 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
1193 fbb_.AddOffset(ResizeAttribute::VT_STRIDE, stride);
1194 }
1195 void add_offset(flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset) {
1196 fbb_.AddOffset(ResizeAttribute::VT_OFFSET, offset);
1197 }
1198 void add_shift(int32_t shift) {
1199 fbb_.AddElement<int32_t>(ResizeAttribute::VT_SHIFT, shift, 0);
1200 }
1201 void add_stride_fp(flatbuffers::Offset<flatbuffers::Vector<float>> stride_fp) {
1202 fbb_.AddOffset(ResizeAttribute::VT_STRIDE_FP, stride_fp);
1203 }
1204 void add_offset_fp(flatbuffers::Offset<flatbuffers::Vector<float>> offset_fp) {
1205 fbb_.AddOffset(ResizeAttribute::VT_OFFSET_FP, offset_fp);
1206 }
1207 void add_mode(tosa::ResizeMode mode) {
1208 fbb_.AddElement<uint32_t>(ResizeAttribute::VT_MODE, static_cast<uint32_t>(mode), 0);
1209 }
1210 explicit ResizeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1211 : fbb_(_fbb) {
1212 start_ = fbb_.StartTable();
1213 }
1214 ResizeAttributeBuilder &operator=(const ResizeAttributeBuilder &);
1215 flatbuffers::Offset<ResizeAttribute> Finish() {
1216 const auto end = fbb_.EndTable(start_);
1217 auto o = flatbuffers::Offset<ResizeAttribute>(end);
1218 return o;
1219 }
1220};
1221
1222inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttribute(
1223 flatbuffers::FlatBufferBuilder &_fbb,
1224 flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size = 0,
1225 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0,
1226 flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset = 0,
1227 int32_t shift = 0,
1228 flatbuffers::Offset<flatbuffers::Vector<float>> stride_fp = 0,
1229 flatbuffers::Offset<flatbuffers::Vector<float>> offset_fp = 0,
1230 tosa::ResizeMode mode = tosa::ResizeMode_UNKNOWN) {
1231 ResizeAttributeBuilder builder_(_fbb);
1232 builder_.add_mode(mode);
1233 builder_.add_offset_fp(offset_fp);
1234 builder_.add_stride_fp(stride_fp);
1235 builder_.add_shift(shift);
1236 builder_.add_offset(offset);
1237 builder_.add_stride(stride);
1238 builder_.add_output_size(output_size);
1239 return builder_.Finish();
1240}
1241
1242inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttributeDirect(
1243 flatbuffers::FlatBufferBuilder &_fbb,
1244 const std::vector<int32_t> *output_size = nullptr,
1245 const std::vector<int32_t> *stride = nullptr,
1246 const std::vector<int32_t> *offset = nullptr,
1247 int32_t shift = 0,
1248 const std::vector<float> *stride_fp = nullptr,
1249 const std::vector<float> *offset_fp = nullptr,
1250 tosa::ResizeMode mode = tosa::ResizeMode_UNKNOWN) {
1251 auto output_size__ = output_size ? _fbb.CreateVector<int32_t>(*output_size) : 0;
1252 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
1253 auto offset__ = offset ? _fbb.CreateVector<int32_t>(*offset) : 0;
1254 auto stride_fp__ = stride_fp ? _fbb.CreateVector<float>(*stride_fp) : 0;
1255 auto offset_fp__ = offset_fp ? _fbb.CreateVector<float>(*offset_fp) : 0;
1256 return tosa::CreateResizeAttribute(
1257 _fbb,
1258 output_size__,
1259 stride__,
1260 offset__,
1261 shift,
1262 stride_fp__,
1263 offset_fp__,
1264 mode);
1265}
1266
1267struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1268 typedef ClampAttributeBuilder Builder;
1269 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1270 VT_MIN_INT = 4,
1271 VT_MAX_INT = 6,
1272 VT_MIN_FP = 8,
1273 VT_MAX_FP = 10
1274 };
1275 int32_t min_int() const {
1276 return GetField<int32_t>(VT_MIN_INT, 0);
1277 }
1278 int32_t max_int() const {
1279 return GetField<int32_t>(VT_MAX_INT, 0);
1280 }
1281 float min_fp() const {
1282 return GetField<float>(VT_MIN_FP, 0.0f);
1283 }
1284 float max_fp() const {
1285 return GetField<float>(VT_MAX_FP, 0.0f);
1286 }
1287 bool Verify(flatbuffers::Verifier &verifier) const {
1288 return VerifyTableStart(verifier) &&
1289 VerifyField<int32_t>(verifier, VT_MIN_INT) &&
1290 VerifyField<int32_t>(verifier, VT_MAX_INT) &&
1291 VerifyField<float>(verifier, VT_MIN_FP) &&
1292 VerifyField<float>(verifier, VT_MAX_FP) &&
1293 verifier.EndTable();
1294 }
1295};
1296
1297struct ClampAttributeBuilder {
1298 typedef ClampAttribute Table;
1299 flatbuffers::FlatBufferBuilder &fbb_;
1300 flatbuffers::uoffset_t start_;
1301 void add_min_int(int32_t min_int) {
1302 fbb_.AddElement<int32_t>(ClampAttribute::VT_MIN_INT, min_int, 0);
1303 }
1304 void add_max_int(int32_t max_int) {
1305 fbb_.AddElement<int32_t>(ClampAttribute::VT_MAX_INT, max_int, 0);
1306 }
1307 void add_min_fp(float min_fp) {
1308 fbb_.AddElement<float>(ClampAttribute::VT_MIN_FP, min_fp, 0.0f);
1309 }
1310 void add_max_fp(float max_fp) {
1311 fbb_.AddElement<float>(ClampAttribute::VT_MAX_FP, max_fp, 0.0f);
1312 }
1313 explicit ClampAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1314 : fbb_(_fbb) {
1315 start_ = fbb_.StartTable();
1316 }
1317 ClampAttributeBuilder &operator=(const ClampAttributeBuilder &);
1318 flatbuffers::Offset<ClampAttribute> Finish() {
1319 const auto end = fbb_.EndTable(start_);
1320 auto o = flatbuffers::Offset<ClampAttribute>(end);
1321 return o;
1322 }
1323};
1324
1325inline flatbuffers::Offset<ClampAttribute> CreateClampAttribute(
1326 flatbuffers::FlatBufferBuilder &_fbb,
1327 int32_t min_int = 0,
1328 int32_t max_int = 0,
1329 float min_fp = 0.0f,
1330 float max_fp = 0.0f) {
1331 ClampAttributeBuilder builder_(_fbb);
1332 builder_.add_max_fp(max_fp);
1333 builder_.add_min_fp(min_fp);
1334 builder_.add_max_int(max_int);
1335 builder_.add_min_int(min_int);
1336 return builder_.Finish();
1337}
1338
1339struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1340 typedef RescaleAttributeBuilder Builder;
1341 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1342 VT_INPUT_ZP = 4,
1343 VT_OUTPUT_ZP = 6,
1344 VT_MULTIPLIER = 8,
1345 VT_SHIFT = 10,
1346 VT_SCALE32 = 12,
1347 VT_DOUBLE_ROUND = 14,
1348 VT_PER_CHANNEL = 16
1349 };
1350 int32_t input_zp() const {
1351 return GetField<int32_t>(VT_INPUT_ZP, 0);
1352 }
1353 int32_t output_zp() const {
1354 return GetField<int32_t>(VT_OUTPUT_ZP, 0);
1355 }
1356 const flatbuffers::Vector<int32_t> *multiplier() const {
1357 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLIER);
1358 }
1359 const flatbuffers::Vector<int32_t> *shift() const {
1360 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHIFT);
1361 }
1362 bool scale32() const {
1363 return GetField<uint8_t>(VT_SCALE32, 0) != 0;
1364 }
1365 bool double_round() const {
1366 return GetField<uint8_t>(VT_DOUBLE_ROUND, 0) != 0;
1367 }
1368 bool per_channel() const {
1369 return GetField<uint8_t>(VT_PER_CHANNEL, 0) != 0;
1370 }
1371 bool Verify(flatbuffers::Verifier &verifier) const {
1372 return VerifyTableStart(verifier) &&
1373 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1374 VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) &&
1375 VerifyOffset(verifier, VT_MULTIPLIER) &&
1376 verifier.VerifyVector(multiplier()) &&
1377 VerifyOffset(verifier, VT_SHIFT) &&
1378 verifier.VerifyVector(shift()) &&
1379 VerifyField<uint8_t>(verifier, VT_SCALE32) &&
1380 VerifyField<uint8_t>(verifier, VT_DOUBLE_ROUND) &&
1381 VerifyField<uint8_t>(verifier, VT_PER_CHANNEL) &&
1382 verifier.EndTable();
1383 }
1384};
1385
1386struct RescaleAttributeBuilder {
1387 typedef RescaleAttribute Table;
1388 flatbuffers::FlatBufferBuilder &fbb_;
1389 flatbuffers::uoffset_t start_;
1390 void add_input_zp(int32_t input_zp) {
1391 fbb_.AddElement<int32_t>(RescaleAttribute::VT_INPUT_ZP, input_zp, 0);
1392 }
1393 void add_output_zp(int32_t output_zp) {
1394 fbb_.AddElement<int32_t>(RescaleAttribute::VT_OUTPUT_ZP, output_zp, 0);
1395 }
1396 void add_multiplier(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier) {
1397 fbb_.AddOffset(RescaleAttribute::VT_MULTIPLIER, multiplier);
1398 }
1399 void add_shift(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift) {
1400 fbb_.AddOffset(RescaleAttribute::VT_SHIFT, shift);
1401 }
1402 void add_scale32(bool scale32) {
1403 fbb_.AddElement<uint8_t>(RescaleAttribute::VT_SCALE32, static_cast<uint8_t>(scale32), 0);
1404 }
1405 void add_double_round(bool double_round) {
1406 fbb_.AddElement<uint8_t>(RescaleAttribute::VT_DOUBLE_ROUND, static_cast<uint8_t>(double_round), 0);
1407 }
1408 void add_per_channel(bool per_channel) {
1409 fbb_.AddElement<uint8_t>(RescaleAttribute::VT_PER_CHANNEL, static_cast<uint8_t>(per_channel), 0);
1410 }
1411 explicit RescaleAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1412 : fbb_(_fbb) {
1413 start_ = fbb_.StartTable();
1414 }
1415 RescaleAttributeBuilder &operator=(const RescaleAttributeBuilder &);
1416 flatbuffers::Offset<RescaleAttribute> Finish() {
1417 const auto end = fbb_.EndTable(start_);
1418 auto o = flatbuffers::Offset<RescaleAttribute>(end);
1419 return o;
1420 }
1421};
1422
1423inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttribute(
1424 flatbuffers::FlatBufferBuilder &_fbb,
1425 int32_t input_zp = 0,
1426 int32_t output_zp = 0,
1427 flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier = 0,
1428 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift = 0,
1429 bool scale32 = false,
1430 bool double_round = false,
1431 bool per_channel = false) {
1432 RescaleAttributeBuilder builder_(_fbb);
1433 builder_.add_shift(shift);
1434 builder_.add_multiplier(multiplier);
1435 builder_.add_output_zp(output_zp);
1436 builder_.add_input_zp(input_zp);
1437 builder_.add_per_channel(per_channel);
1438 builder_.add_double_round(double_round);
1439 builder_.add_scale32(scale32);
1440 return builder_.Finish();
1441}
1442
1443inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttributeDirect(
1444 flatbuffers::FlatBufferBuilder &_fbb,
1445 int32_t input_zp = 0,
1446 int32_t output_zp = 0,
1447 const std::vector<int32_t> *multiplier = nullptr,
1448 const std::vector<int32_t> *shift = nullptr,
1449 bool scale32 = false,
1450 bool double_round = false,
1451 bool per_channel = false) {
1452 auto multiplier__ = multiplier ? _fbb.CreateVector<int32_t>(*multiplier) : 0;
1453 auto shift__ = shift ? _fbb.CreateVector<int32_t>(*shift) : 0;
1454 return tosa::CreateRescaleAttribute(
1455 _fbb,
1456 input_zp,
1457 output_zp,
1458 multiplier__,
1459 shift__,
1460 scale32,
1461 double_round,
1462 per_channel);
1463}
1464
1465struct MulAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1466 typedef MulAttributeBuilder Builder;
1467 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1468 VT_SHIFT = 4
1469 };
1470 int32_t shift() const {
1471 return GetField<int32_t>(VT_SHIFT, 0);
1472 }
1473 bool Verify(flatbuffers::Verifier &verifier) const {
1474 return VerifyTableStart(verifier) &&
1475 VerifyField<int32_t>(verifier, VT_SHIFT) &&
1476 verifier.EndTable();
1477 }
1478};
1479
1480struct MulAttributeBuilder {
1481 typedef MulAttribute Table;
1482 flatbuffers::FlatBufferBuilder &fbb_;
1483 flatbuffers::uoffset_t start_;
1484 void add_shift(int32_t shift) {
1485 fbb_.AddElement<int32_t>(MulAttribute::VT_SHIFT, shift, 0);
1486 }
1487 explicit MulAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1488 : fbb_(_fbb) {
1489 start_ = fbb_.StartTable();
1490 }
1491 MulAttributeBuilder &operator=(const MulAttributeBuilder &);
1492 flatbuffers::Offset<MulAttribute> Finish() {
1493 const auto end = fbb_.EndTable(start_);
1494 auto o = flatbuffers::Offset<MulAttribute>(end);
1495 return o;
1496 }
1497};
1498
1499inline flatbuffers::Offset<MulAttribute> CreateMulAttribute(
1500 flatbuffers::FlatBufferBuilder &_fbb,
1501 int32_t shift = 0) {
1502 MulAttributeBuilder builder_(_fbb);
1503 builder_.add_shift(shift);
1504 return builder_.Finish();
1505}
1506
1507struct ArithmeticRightShiftAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1508 typedef ArithmeticRightShiftAttributeBuilder Builder;
1509 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1510 VT_ROUND = 4
1511 };
1512 bool round() const {
1513 return GetField<uint8_t>(VT_ROUND, 0) != 0;
1514 }
1515 bool Verify(flatbuffers::Verifier &verifier) const {
1516 return VerifyTableStart(verifier) &&
1517 VerifyField<uint8_t>(verifier, VT_ROUND) &&
1518 verifier.EndTable();
1519 }
1520};
1521
1522struct ArithmeticRightShiftAttributeBuilder {
1523 typedef ArithmeticRightShiftAttribute Table;
1524 flatbuffers::FlatBufferBuilder &fbb_;
1525 flatbuffers::uoffset_t start_;
1526 void add_round(bool round) {
1527 fbb_.AddElement<uint8_t>(ArithmeticRightShiftAttribute::VT_ROUND, static_cast<uint8_t>(round), 0);
1528 }
1529 explicit ArithmeticRightShiftAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1530 : fbb_(_fbb) {
1531 start_ = fbb_.StartTable();
1532 }
1533 ArithmeticRightShiftAttributeBuilder &operator=(const ArithmeticRightShiftAttributeBuilder &);
1534 flatbuffers::Offset<ArithmeticRightShiftAttribute> Finish() {
1535 const auto end = fbb_.EndTable(start_);
1536 auto o = flatbuffers::Offset<ArithmeticRightShiftAttribute>(end);
1537 return o;
1538 }
1539};
1540
1541inline flatbuffers::Offset<ArithmeticRightShiftAttribute> CreateArithmeticRightShiftAttribute(
1542 flatbuffers::FlatBufferBuilder &_fbb,
1543 bool round = false) {
1544 ArithmeticRightShiftAttributeBuilder builder_(_fbb);
1545 builder_.add_round(round);
1546 return builder_.Finish();
1547}
1548
1549struct CondIfAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1550 typedef CondIfAttributeBuilder Builder;
1551 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1552 VT_THEN_BRANCH = 4,
1553 VT_ELSE_BRANCH = 6
1554 };
1555 const flatbuffers::String *then_branch() const {
1556 return GetPointer<const flatbuffers::String *>(VT_THEN_BRANCH);
1557 }
1558 const flatbuffers::String *else_branch() const {
1559 return GetPointer<const flatbuffers::String *>(VT_ELSE_BRANCH);
1560 }
1561 bool Verify(flatbuffers::Verifier &verifier) const {
1562 return VerifyTableStart(verifier) &&
1563 VerifyOffset(verifier, VT_THEN_BRANCH) &&
1564 verifier.VerifyString(then_branch()) &&
1565 VerifyOffset(verifier, VT_ELSE_BRANCH) &&
1566 verifier.VerifyString(else_branch()) &&
1567 verifier.EndTable();
1568 }
1569};
1570
1571struct CondIfAttributeBuilder {
1572 typedef CondIfAttribute Table;
1573 flatbuffers::FlatBufferBuilder &fbb_;
1574 flatbuffers::uoffset_t start_;
1575 void add_then_branch(flatbuffers::Offset<flatbuffers::String> then_branch) {
1576 fbb_.AddOffset(CondIfAttribute::VT_THEN_BRANCH, then_branch);
1577 }
1578 void add_else_branch(flatbuffers::Offset<flatbuffers::String> else_branch) {
1579 fbb_.AddOffset(CondIfAttribute::VT_ELSE_BRANCH, else_branch);
1580 }
1581 explicit CondIfAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1582 : fbb_(_fbb) {
1583 start_ = fbb_.StartTable();
1584 }
1585 CondIfAttributeBuilder &operator=(const CondIfAttributeBuilder &);
1586 flatbuffers::Offset<CondIfAttribute> Finish() {
1587 const auto end = fbb_.EndTable(start_);
1588 auto o = flatbuffers::Offset<CondIfAttribute>(end);
1589 return o;
1590 }
1591};
1592
1593inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttribute(
1594 flatbuffers::FlatBufferBuilder &_fbb,
1595 flatbuffers::Offset<flatbuffers::String> then_branch = 0,
1596 flatbuffers::Offset<flatbuffers::String> else_branch = 0) {
1597 CondIfAttributeBuilder builder_(_fbb);
1598 builder_.add_else_branch(else_branch);
1599 builder_.add_then_branch(then_branch);
1600 return builder_.Finish();
1601}
1602
1603inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttributeDirect(
1604 flatbuffers::FlatBufferBuilder &_fbb,
1605 const char *then_branch = nullptr,
1606 const char *else_branch = nullptr) {
1607 auto then_branch__ = then_branch ? _fbb.CreateString(then_branch) : 0;
1608 auto else_branch__ = else_branch ? _fbb.CreateString(else_branch) : 0;
1609 return tosa::CreateCondIfAttribute(
1610 _fbb,
1611 then_branch__,
1612 else_branch__);
1613}
1614
1615struct WhileLoopAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1616 typedef WhileLoopAttributeBuilder Builder;
1617 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1618 VT_COND_BRANCH = 4,
1619 VT_BODY_BRANCH = 6
1620 };
1621 const flatbuffers::String *cond_branch() const {
1622 return GetPointer<const flatbuffers::String *>(VT_COND_BRANCH);
1623 }
1624 const flatbuffers::String *body_branch() const {
1625 return GetPointer<const flatbuffers::String *>(VT_BODY_BRANCH);
1626 }
1627 bool Verify(flatbuffers::Verifier &verifier) const {
1628 return VerifyTableStart(verifier) &&
1629 VerifyOffset(verifier, VT_COND_BRANCH) &&
1630 verifier.VerifyString(cond_branch()) &&
1631 VerifyOffset(verifier, VT_BODY_BRANCH) &&
1632 verifier.VerifyString(body_branch()) &&
1633 verifier.EndTable();
1634 }
1635};
1636
1637struct WhileLoopAttributeBuilder {
1638 typedef WhileLoopAttribute Table;
1639 flatbuffers::FlatBufferBuilder &fbb_;
1640 flatbuffers::uoffset_t start_;
1641 void add_cond_branch(flatbuffers::Offset<flatbuffers::String> cond_branch) {
1642 fbb_.AddOffset(WhileLoopAttribute::VT_COND_BRANCH, cond_branch);
1643 }
1644 void add_body_branch(flatbuffers::Offset<flatbuffers::String> body_branch) {
1645 fbb_.AddOffset(WhileLoopAttribute::VT_BODY_BRANCH, body_branch);
1646 }
1647 explicit WhileLoopAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1648 : fbb_(_fbb) {
1649 start_ = fbb_.StartTable();
1650 }
1651 WhileLoopAttributeBuilder &operator=(const WhileLoopAttributeBuilder &);
1652 flatbuffers::Offset<WhileLoopAttribute> Finish() {
1653 const auto end = fbb_.EndTable(start_);
1654 auto o = flatbuffers::Offset<WhileLoopAttribute>(end);
1655 return o;
1656 }
1657};
1658
1659inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttribute(
1660 flatbuffers::FlatBufferBuilder &_fbb,
1661 flatbuffers::Offset<flatbuffers::String> cond_branch = 0,
1662 flatbuffers::Offset<flatbuffers::String> body_branch = 0) {
1663 WhileLoopAttributeBuilder builder_(_fbb);
1664 builder_.add_body_branch(body_branch);
1665 builder_.add_cond_branch(cond_branch);
1666 return builder_.Finish();
1667}
1668
1669inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttributeDirect(
1670 flatbuffers::FlatBufferBuilder &_fbb,
1671 const char *cond_branch = nullptr,
1672 const char *body_branch = nullptr) {
1673 auto cond_branch__ = cond_branch ? _fbb.CreateString(cond_branch) : 0;
1674 auto body_branch__ = body_branch ? _fbb.CreateString(body_branch) : 0;
1675 return tosa::CreateWhileLoopAttribute(
1676 _fbb,
1677 cond_branch__,
1678 body_branch__);
1679}
1680
1681struct UnaryQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1682 typedef UnaryQuantInfoBuilder Builder;
1683 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1684 VT_INPUT_ZP = 4,
1685 VT_OUTPUT_ZP = 6
1686 };
1687 int32_t input_zp() const {
1688 return GetField<int32_t>(VT_INPUT_ZP, 0);
1689 }
1690 int32_t output_zp() const {
1691 return GetField<int32_t>(VT_OUTPUT_ZP, 0);
1692 }
1693 bool Verify(flatbuffers::Verifier &verifier) const {
1694 return VerifyTableStart(verifier) &&
1695 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1696 VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) &&
1697 verifier.EndTable();
1698 }
1699};
1700
1701struct UnaryQuantInfoBuilder {
1702 typedef UnaryQuantInfo Table;
1703 flatbuffers::FlatBufferBuilder &fbb_;
1704 flatbuffers::uoffset_t start_;
1705 void add_input_zp(int32_t input_zp) {
1706 fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_INPUT_ZP, input_zp, 0);
1707 }
1708 void add_output_zp(int32_t output_zp) {
1709 fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_OUTPUT_ZP, output_zp, 0);
1710 }
1711 explicit UnaryQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1712 : fbb_(_fbb) {
1713 start_ = fbb_.StartTable();
1714 }
1715 UnaryQuantInfoBuilder &operator=(const UnaryQuantInfoBuilder &);
1716 flatbuffers::Offset<UnaryQuantInfo> Finish() {
1717 const auto end = fbb_.EndTable(start_);
1718 auto o = flatbuffers::Offset<UnaryQuantInfo>(end);
1719 return o;
1720 }
1721};
1722
1723inline flatbuffers::Offset<UnaryQuantInfo> CreateUnaryQuantInfo(
1724 flatbuffers::FlatBufferBuilder &_fbb,
1725 int32_t input_zp = 0,
1726 int32_t output_zp = 0) {
1727 UnaryQuantInfoBuilder builder_(_fbb);
1728 builder_.add_output_zp(output_zp);
1729 builder_.add_input_zp(input_zp);
1730 return builder_.Finish();
1731}
1732
1733struct ConvQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1734 typedef ConvQuantInfoBuilder Builder;
1735 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1736 VT_INPUT_ZP = 4,
1737 VT_WEIGHT_ZP = 6
1738 };
1739 int32_t input_zp() const {
1740 return GetField<int32_t>(VT_INPUT_ZP, 0);
1741 }
1742 int32_t weight_zp() const {
1743 return GetField<int32_t>(VT_WEIGHT_ZP, 0);
1744 }
1745 bool Verify(flatbuffers::Verifier &verifier) const {
1746 return VerifyTableStart(verifier) &&
1747 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1748 VerifyField<int32_t>(verifier, VT_WEIGHT_ZP) &&
1749 verifier.EndTable();
1750 }
1751};
1752
1753struct ConvQuantInfoBuilder {
1754 typedef ConvQuantInfo Table;
1755 flatbuffers::FlatBufferBuilder &fbb_;
1756 flatbuffers::uoffset_t start_;
1757 void add_input_zp(int32_t input_zp) {
1758 fbb_.AddElement<int32_t>(ConvQuantInfo::VT_INPUT_ZP, input_zp, 0);
1759 }
1760 void add_weight_zp(int32_t weight_zp) {
1761 fbb_.AddElement<int32_t>(ConvQuantInfo::VT_WEIGHT_ZP, weight_zp, 0);
1762 }
1763 explicit ConvQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1764 : fbb_(_fbb) {
1765 start_ = fbb_.StartTable();
1766 }
1767 ConvQuantInfoBuilder &operator=(const ConvQuantInfoBuilder &);
1768 flatbuffers::Offset<ConvQuantInfo> Finish() {
1769 const auto end = fbb_.EndTable(start_);
1770 auto o = flatbuffers::Offset<ConvQuantInfo>(end);
1771 return o;
1772 }
1773};
1774
1775inline flatbuffers::Offset<ConvQuantInfo> CreateConvQuantInfo(
1776 flatbuffers::FlatBufferBuilder &_fbb,
1777 int32_t input_zp = 0,
1778 int32_t weight_zp = 0) {
1779 ConvQuantInfoBuilder builder_(_fbb);
1780 builder_.add_weight_zp(weight_zp);
1781 builder_.add_input_zp(input_zp);
1782 return builder_.Finish();
1783}
1784
1785struct MatMulQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1786 typedef MatMulQuantInfoBuilder Builder;
1787 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1788 VT_A_ZP = 4,
1789 VT_B_ZP = 6
1790 };
1791 int32_t a_zp() const {
1792 return GetField<int32_t>(VT_A_ZP, 0);
1793 }
1794 int32_t b_zp() const {
1795 return GetField<int32_t>(VT_B_ZP, 0);
1796 }
1797 bool Verify(flatbuffers::Verifier &verifier) const {
1798 return VerifyTableStart(verifier) &&
1799 VerifyField<int32_t>(verifier, VT_A_ZP) &&
1800 VerifyField<int32_t>(verifier, VT_B_ZP) &&
1801 verifier.EndTable();
1802 }
1803};
1804
1805struct MatMulQuantInfoBuilder {
1806 typedef MatMulQuantInfo Table;
1807 flatbuffers::FlatBufferBuilder &fbb_;
1808 flatbuffers::uoffset_t start_;
1809 void add_a_zp(int32_t a_zp) {
1810 fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_A_ZP, a_zp, 0);
1811 }
1812 void add_b_zp(int32_t b_zp) {
1813 fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_B_ZP, b_zp, 0);
1814 }
1815 explicit MatMulQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1816 : fbb_(_fbb) {
1817 start_ = fbb_.StartTable();
1818 }
1819 MatMulQuantInfoBuilder &operator=(const MatMulQuantInfoBuilder &);
1820 flatbuffers::Offset<MatMulQuantInfo> Finish() {
1821 const auto end = fbb_.EndTable(start_);
1822 auto o = flatbuffers::Offset<MatMulQuantInfo>(end);
1823 return o;
1824 }
1825};
1826
1827inline flatbuffers::Offset<MatMulQuantInfo> CreateMatMulQuantInfo(
1828 flatbuffers::FlatBufferBuilder &_fbb,
1829 int32_t a_zp = 0,
1830 int32_t b_zp = 0) {
1831 MatMulQuantInfoBuilder builder_(_fbb);
1832 builder_.add_b_zp(b_zp);
1833 builder_.add_a_zp(a_zp);
1834 return builder_.Finish();
1835}
1836
1837struct PadQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1838 typedef PadQuantInfoBuilder Builder;
1839 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1840 VT_INPUT_ZP = 4
1841 };
1842 int32_t input_zp() const {
1843 return GetField<int32_t>(VT_INPUT_ZP, 0);
1844 }
1845 bool Verify(flatbuffers::Verifier &verifier) const {
1846 return VerifyTableStart(verifier) &&
1847 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1848 verifier.EndTable();
1849 }
1850};
1851
1852struct PadQuantInfoBuilder {
1853 typedef PadQuantInfo Table;
1854 flatbuffers::FlatBufferBuilder &fbb_;
1855 flatbuffers::uoffset_t start_;
1856 void add_input_zp(int32_t input_zp) {
1857 fbb_.AddElement<int32_t>(PadQuantInfo::VT_INPUT_ZP, input_zp, 0);
1858 }
1859 explicit PadQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1860 : fbb_(_fbb) {
1861 start_ = fbb_.StartTable();
1862 }
1863 PadQuantInfoBuilder &operator=(const PadQuantInfoBuilder &);
1864 flatbuffers::Offset<PadQuantInfo> Finish() {
1865 const auto end = fbb_.EndTable(start_);
1866 auto o = flatbuffers::Offset<PadQuantInfo>(end);
1867 return o;
1868 }
1869};
1870
1871inline flatbuffers::Offset<PadQuantInfo> CreatePadQuantInfo(
1872 flatbuffers::FlatBufferBuilder &_fbb,
1873 int32_t input_zp = 0) {
1874 PadQuantInfoBuilder builder_(_fbb);
1875 builder_.add_input_zp(input_zp);
1876 return builder_.Finish();
1877}
1878
1879struct Version FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1880 typedef VersionBuilder Builder;
1881 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1882 VT__MAJOR = 4,
1883 VT__MINOR = 6,
1884 VT__PATCH = 8,
1885 VT__EXPERIMENTAL = 10
1886 };
1887 int32_t _major() const {
1888 return GetField<int32_t>(VT__MAJOR, 0);
1889 }
1890 int32_t _minor() const {
1891 return GetField<int32_t>(VT__MINOR, 21);
1892 }
1893 int32_t _patch() const {
1894 return GetField<int32_t>(VT__PATCH, 0);
1895 }
1896 bool _experimental() const {
1897 return GetField<uint8_t>(VT__EXPERIMENTAL, 0) != 0;
1898 }
1899 bool Verify(flatbuffers::Verifier &verifier) const {
1900 return VerifyTableStart(verifier) &&
1901 VerifyField<int32_t>(verifier, VT__MAJOR) &&
1902 VerifyField<int32_t>(verifier, VT__MINOR) &&
1903 VerifyField<int32_t>(verifier, VT__PATCH) &&
1904 VerifyField<uint8_t>(verifier, VT__EXPERIMENTAL) &&
1905 verifier.EndTable();
1906 }
1907};
1908
1909struct VersionBuilder {
1910 typedef Version Table;
1911 flatbuffers::FlatBufferBuilder &fbb_;
1912 flatbuffers::uoffset_t start_;
1913 void add__major(int32_t _major) {
1914 fbb_.AddElement<int32_t>(Version::VT__MAJOR, _major, 0);
1915 }
1916 void add__minor(int32_t _minor) {
1917 fbb_.AddElement<int32_t>(Version::VT__MINOR, _minor, 21);
1918 }
1919 void add__patch(int32_t _patch) {
1920 fbb_.AddElement<int32_t>(Version::VT__PATCH, _patch, 0);
1921 }
1922 void add__experimental(bool _experimental) {
1923 fbb_.AddElement<uint8_t>(Version::VT__EXPERIMENTAL, static_cast<uint8_t>(_experimental), 0);
1924 }
1925 explicit VersionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1926 : fbb_(_fbb) {
1927 start_ = fbb_.StartTable();
1928 }
1929 VersionBuilder &operator=(const VersionBuilder &);
1930 flatbuffers::Offset<Version> Finish() {
1931 const auto end = fbb_.EndTable(start_);
1932 auto o = flatbuffers::Offset<Version>(end);
1933 return o;
1934 }
1935};
1936
1937inline flatbuffers::Offset<Version> CreateVersion(
1938 flatbuffers::FlatBufferBuilder &_fbb,
1939 int32_t _major = 0,
1940 int32_t _minor = 21,
1941 int32_t _patch = 0,
1942 bool _experimental = false) {
1943 VersionBuilder builder_(_fbb);
1944 builder_.add__patch(_patch);
1945 builder_.add__minor(_minor);
1946 builder_.add__major(_major);
1947 builder_.add__experimental(_experimental);
1948 return builder_.Finish();
1949}
1950
1951struct TosaTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1952 typedef TosaTensorBuilder Builder;
1953 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1954 VT_NAME = 4,
1955 VT_SHAPE = 6,
1956 VT_TYPE = 8,
1957 VT_NPY_FILENAME = 10
1958 };
1959 const flatbuffers::String *name() const {
1960 return GetPointer<const flatbuffers::String *>(VT_NAME);
1961 }
1962 const flatbuffers::Vector<int32_t> *shape() const {
1963 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
1964 }
1965 tosa::DType type() const {
1966 return static_cast<tosa::DType>(GetField<uint32_t>(VT_TYPE, 0));
1967 }
1968 const flatbuffers::String *npy_filename() const {
1969 return GetPointer<const flatbuffers::String *>(VT_NPY_FILENAME);
1970 }
1971 bool Verify(flatbuffers::Verifier &verifier) const {
1972 return VerifyTableStart(verifier) &&
1973 VerifyOffset(verifier, VT_NAME) &&
1974 verifier.VerifyString(name()) &&
1975 VerifyOffset(verifier, VT_SHAPE) &&
1976 verifier.VerifyVector(shape()) &&
1977 VerifyField<uint32_t>(verifier, VT_TYPE) &&
1978 VerifyOffset(verifier, VT_NPY_FILENAME) &&
1979 verifier.VerifyString(npy_filename()) &&
1980 verifier.EndTable();
1981 }
1982};
1983
1984struct TosaTensorBuilder {
1985 typedef TosaTensor Table;
1986 flatbuffers::FlatBufferBuilder &fbb_;
1987 flatbuffers::uoffset_t start_;
1988 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
1989 fbb_.AddOffset(TosaTensor::VT_NAME, name);
1990 }
1991 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
1992 fbb_.AddOffset(TosaTensor::VT_SHAPE, shape);
1993 }
1994 void add_type(tosa::DType type) {
1995 fbb_.AddElement<uint32_t>(TosaTensor::VT_TYPE, static_cast<uint32_t>(type), 0);
1996 }
1997 void add_npy_filename(flatbuffers::Offset<flatbuffers::String> npy_filename) {
1998 fbb_.AddOffset(TosaTensor::VT_NPY_FILENAME, npy_filename);
1999 }
2000 explicit TosaTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2001 : fbb_(_fbb) {
2002 start_ = fbb_.StartTable();
2003 }
2004 TosaTensorBuilder &operator=(const TosaTensorBuilder &);
2005 flatbuffers::Offset<TosaTensor> Finish() {
2006 const auto end = fbb_.EndTable(start_);
2007 auto o = flatbuffers::Offset<TosaTensor>(end);
2008 return o;
2009 }
2010};
2011
2012inline flatbuffers::Offset<TosaTensor> CreateTosaTensor(
2013 flatbuffers::FlatBufferBuilder &_fbb,
2014 flatbuffers::Offset<flatbuffers::String> name = 0,
2015 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
2016 tosa::DType type = tosa::DType_UNKNOWN,
2017 flatbuffers::Offset<flatbuffers::String> npy_filename = 0) {
2018 TosaTensorBuilder builder_(_fbb);
2019 builder_.add_npy_filename(npy_filename);
2020 builder_.add_type(type);
2021 builder_.add_shape(shape);
2022 builder_.add_name(name);
2023 return builder_.Finish();
2024}
2025
2026inline flatbuffers::Offset<TosaTensor> CreateTosaTensorDirect(
2027 flatbuffers::FlatBufferBuilder &_fbb,
2028 const char *name = nullptr,
2029 const std::vector<int32_t> *shape = nullptr,
2030 tosa::DType type = tosa::DType_UNKNOWN,
2031 const char *npy_filename = nullptr) {
2032 auto name__ = name ? _fbb.CreateString(name) : 0;
2033 auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
2034 auto npy_filename__ = npy_filename ? _fbb.CreateString(npy_filename) : 0;
2035 return tosa::CreateTosaTensor(
2036 _fbb,
2037 name__,
2038 shape__,
2039 type,
2040 npy_filename__);
2041}
2042
2043struct TosaOperator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2044 typedef TosaOperatorBuilder Builder;
2045 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2046 VT_OP = 4,
2047 VT_ATTRIBUTE_TYPE = 6,
2048 VT_ATTRIBUTE = 8,
2049 VT_INPUTS = 10,
2050 VT_OUTPUTS = 12,
2051 VT_QUANT_INFO_TYPE = 14,
2052 VT_QUANT_INFO = 16
2053 };
2054 tosa::Op op() const {
2055 return static_cast<tosa::Op>(GetField<uint32_t>(VT_OP, 0));
2056 }
2057 tosa::Attribute attribute_type() const {
2058 return static_cast<tosa::Attribute>(GetField<uint8_t>(VT_ATTRIBUTE_TYPE, 0));
2059 }
2060 const void *attribute() const {
2061 return GetPointer<const void *>(VT_ATTRIBUTE);
2062 }
2063 template<typename T> const T *attribute_as() const;
2064 const tosa::Pool2dAttribute *attribute_as_Pool2dAttribute() const {
2065 return attribute_type() == tosa::Attribute_Pool2dAttribute ? static_cast<const tosa::Pool2dAttribute *>(attribute()) : nullptr;
2066 }
2067 const tosa::Conv2dAttribute *attribute_as_Conv2dAttribute() const {
2068 return attribute_type() == tosa::Attribute_Conv2dAttribute ? static_cast<const tosa::Conv2dAttribute *>(attribute()) : nullptr;
2069 }
2070 const tosa::TransposeConv2dAttribute *attribute_as_TransposeConv2dAttribute() const {
2071 return attribute_type() == tosa::Attribute_TransposeConv2dAttribute ? static_cast<const tosa::TransposeConv2dAttribute *>(attribute()) : nullptr;
2072 }
2073 const tosa::ReluNAttribute *attribute_as_ReluNAttribute() const {
2074 return attribute_type() == tosa::Attribute_ReluNAttribute ? static_cast<const tosa::ReluNAttribute *>(attribute()) : nullptr;
2075 }
2076 const tosa::AxisAttribute *attribute_as_AxisAttribute() const {
2077 return attribute_type() == tosa::Attribute_AxisAttribute ? static_cast<const tosa::AxisAttribute *>(attribute()) : nullptr;
2078 }
2079 const tosa::ReshapeAttribute *attribute_as_ReshapeAttribute() const {
2080 return attribute_type() == tosa::Attribute_ReshapeAttribute ? static_cast<const tosa::ReshapeAttribute *>(attribute()) : nullptr;
2081 }
2082 const tosa::SliceAttribute *attribute_as_SliceAttribute() const {
2083 return attribute_type() == tosa::Attribute_SliceAttribute ? static_cast<const tosa::SliceAttribute *>(attribute()) : nullptr;
2084 }
2085 const tosa::TileAttribute *attribute_as_TileAttribute() const {
2086 return attribute_type() == tosa::Attribute_TileAttribute ? static_cast<const tosa::TileAttribute *>(attribute()) : nullptr;
2087 }
2088 const tosa::ResizeAttribute *attribute_as_ResizeAttribute() const {
2089 return attribute_type() == tosa::Attribute_ResizeAttribute ? static_cast<const tosa::ResizeAttribute *>(attribute()) : nullptr;
2090 }
2091 const tosa::ClampAttribute *attribute_as_ClampAttribute() const {
2092 return attribute_type() == tosa::Attribute_ClampAttribute ? static_cast<const tosa::ClampAttribute *>(attribute()) : nullptr;
2093 }
2094 const tosa::RescaleAttribute *attribute_as_RescaleAttribute() const {
2095 return attribute_type() == tosa::Attribute_RescaleAttribute ? static_cast<const tosa::RescaleAttribute *>(attribute()) : nullptr;
2096 }
2097 const tosa::MulAttribute *attribute_as_MulAttribute() const {
2098 return attribute_type() == tosa::Attribute_MulAttribute ? static_cast<const tosa::MulAttribute *>(attribute()) : nullptr;
2099 }
2100 const tosa::ArithmeticRightShiftAttribute *attribute_as_ArithmeticRightShiftAttribute() const {
2101 return attribute_type() == tosa::Attribute_ArithmeticRightShiftAttribute ? static_cast<const tosa::ArithmeticRightShiftAttribute *>(attribute()) : nullptr;
2102 }
2103 const tosa::CondIfAttribute *attribute_as_CondIfAttribute() const {
2104 return attribute_type() == tosa::Attribute_CondIfAttribute ? static_cast<const tosa::CondIfAttribute *>(attribute()) : nullptr;
2105 }
2106 const tosa::WhileLoopAttribute *attribute_as_WhileLoopAttribute() const {
2107 return attribute_type() == tosa::Attribute_WhileLoopAttribute ? static_cast<const tosa::WhileLoopAttribute *>(attribute()) : nullptr;
2108 }
2109 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const {
2110 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS);
2111 }
2112 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const {
2113 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS);
2114 }
2115 tosa::QuantInfo quant_info_type() const {
2116 return static_cast<tosa::QuantInfo>(GetField<uint8_t>(VT_QUANT_INFO_TYPE, 0));
2117 }
2118 const void *quant_info() const {
2119 return GetPointer<const void *>(VT_QUANT_INFO);
2120 }
2121 template<typename T> const T *quant_info_as() const;
2122 const tosa::UnaryQuantInfo *quant_info_as_UnaryQuantInfo() const {
2123 return quant_info_type() == tosa::QuantInfo_UnaryQuantInfo ? static_cast<const tosa::UnaryQuantInfo *>(quant_info()) : nullptr;
2124 }
2125 const tosa::ConvQuantInfo *quant_info_as_ConvQuantInfo() const {
2126 return quant_info_type() == tosa::QuantInfo_ConvQuantInfo ? static_cast<const tosa::ConvQuantInfo *>(quant_info()) : nullptr;
2127 }
2128 const tosa::MatMulQuantInfo *quant_info_as_MatMulQuantInfo() const {
2129 return quant_info_type() == tosa::QuantInfo_MatMulQuantInfo ? static_cast<const tosa::MatMulQuantInfo *>(quant_info()) : nullptr;
2130 }
2131 const tosa::PadQuantInfo *quant_info_as_PadQuantInfo() const {
2132 return quant_info_type() == tosa::QuantInfo_PadQuantInfo ? static_cast<const tosa::PadQuantInfo *>(quant_info()) : nullptr;
2133 }
2134 bool Verify(flatbuffers::Verifier &verifier) const {
2135 return VerifyTableStart(verifier) &&
2136 VerifyField<uint32_t>(verifier, VT_OP) &&
2137 VerifyField<uint8_t>(verifier, VT_ATTRIBUTE_TYPE) &&
2138 VerifyOffset(verifier, VT_ATTRIBUTE) &&
2139 VerifyAttribute(verifier, attribute(), attribute_type()) &&
2140 VerifyOffset(verifier, VT_INPUTS) &&
2141 verifier.VerifyVector(inputs()) &&
2142 verifier.VerifyVectorOfStrings(inputs()) &&
2143 VerifyOffset(verifier, VT_OUTPUTS) &&
2144 verifier.VerifyVector(outputs()) &&
2145 verifier.VerifyVectorOfStrings(outputs()) &&
2146 VerifyField<uint8_t>(verifier, VT_QUANT_INFO_TYPE) &&
2147 VerifyOffset(verifier, VT_QUANT_INFO) &&
2148 VerifyQuantInfo(verifier, quant_info(), quant_info_type()) &&
2149 verifier.EndTable();
2150 }
2151};
2152
2153template<> inline const tosa::Pool2dAttribute *TosaOperator::attribute_as<tosa::Pool2dAttribute>() const {
2154 return attribute_as_Pool2dAttribute();
2155}
2156
2157template<> inline const tosa::Conv2dAttribute *TosaOperator::attribute_as<tosa::Conv2dAttribute>() const {
2158 return attribute_as_Conv2dAttribute();
2159}
2160
2161template<> inline const tosa::TransposeConv2dAttribute *TosaOperator::attribute_as<tosa::TransposeConv2dAttribute>() const {
2162 return attribute_as_TransposeConv2dAttribute();
2163}
2164
2165template<> inline const tosa::ReluNAttribute *TosaOperator::attribute_as<tosa::ReluNAttribute>() const {
2166 return attribute_as_ReluNAttribute();
2167}
2168
2169template<> inline const tosa::AxisAttribute *TosaOperator::attribute_as<tosa::AxisAttribute>() const {
2170 return attribute_as_AxisAttribute();
2171}
2172
2173template<> inline const tosa::ReshapeAttribute *TosaOperator::attribute_as<tosa::ReshapeAttribute>() const {
2174 return attribute_as_ReshapeAttribute();
2175}
2176
2177template<> inline const tosa::SliceAttribute *TosaOperator::attribute_as<tosa::SliceAttribute>() const {
2178 return attribute_as_SliceAttribute();
2179}
2180
2181template<> inline const tosa::TileAttribute *TosaOperator::attribute_as<tosa::TileAttribute>() const {
2182 return attribute_as_TileAttribute();
2183}
2184
2185template<> inline const tosa::ResizeAttribute *TosaOperator::attribute_as<tosa::ResizeAttribute>() const {
2186 return attribute_as_ResizeAttribute();
2187}
2188
2189template<> inline const tosa::ClampAttribute *TosaOperator::attribute_as<tosa::ClampAttribute>() const {
2190 return attribute_as_ClampAttribute();
2191}
2192
2193template<> inline const tosa::RescaleAttribute *TosaOperator::attribute_as<tosa::RescaleAttribute>() const {
2194 return attribute_as_RescaleAttribute();
2195}
2196
2197template<> inline const tosa::MulAttribute *TosaOperator::attribute_as<tosa::MulAttribute>() const {
2198 return attribute_as_MulAttribute();
2199}
2200
2201template<> inline const tosa::ArithmeticRightShiftAttribute *TosaOperator::attribute_as<tosa::ArithmeticRightShiftAttribute>() const {
2202 return attribute_as_ArithmeticRightShiftAttribute();
2203}
2204
2205template<> inline const tosa::CondIfAttribute *TosaOperator::attribute_as<tosa::CondIfAttribute>() const {
2206 return attribute_as_CondIfAttribute();
2207}
2208
2209template<> inline const tosa::WhileLoopAttribute *TosaOperator::attribute_as<tosa::WhileLoopAttribute>() const {
2210 return attribute_as_WhileLoopAttribute();
2211}
2212
2213template<> inline const tosa::UnaryQuantInfo *TosaOperator::quant_info_as<tosa::UnaryQuantInfo>() const {
2214 return quant_info_as_UnaryQuantInfo();
2215}
2216
2217template<> inline const tosa::ConvQuantInfo *TosaOperator::quant_info_as<tosa::ConvQuantInfo>() const {
2218 return quant_info_as_ConvQuantInfo();
2219}
2220
2221template<> inline const tosa::MatMulQuantInfo *TosaOperator::quant_info_as<tosa::MatMulQuantInfo>() const {
2222 return quant_info_as_MatMulQuantInfo();
2223}
2224
2225template<> inline const tosa::PadQuantInfo *TosaOperator::quant_info_as<tosa::PadQuantInfo>() const {
2226 return quant_info_as_PadQuantInfo();
2227}
2228
2229struct TosaOperatorBuilder {
2230 typedef TosaOperator Table;
2231 flatbuffers::FlatBufferBuilder &fbb_;
2232 flatbuffers::uoffset_t start_;
2233 void add_op(tosa::Op op) {
2234 fbb_.AddElement<uint32_t>(TosaOperator::VT_OP, static_cast<uint32_t>(op), 0);
2235 }
2236 void add_attribute_type(tosa::Attribute attribute_type) {
2237 fbb_.AddElement<uint8_t>(TosaOperator::VT_ATTRIBUTE_TYPE, static_cast<uint8_t>(attribute_type), 0);
2238 }
2239 void add_attribute(flatbuffers::Offset<void> attribute) {
2240 fbb_.AddOffset(TosaOperator::VT_ATTRIBUTE, attribute);
2241 }
2242 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) {
2243 fbb_.AddOffset(TosaOperator::VT_INPUTS, inputs);
2244 }
2245 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) {
2246 fbb_.AddOffset(TosaOperator::VT_OUTPUTS, outputs);
2247 }
2248 void add_quant_info_type(tosa::QuantInfo quant_info_type) {
2249 fbb_.AddElement<uint8_t>(TosaOperator::VT_QUANT_INFO_TYPE, static_cast<uint8_t>(quant_info_type), 0);
2250 }
2251 void add_quant_info(flatbuffers::Offset<void> quant_info) {
2252 fbb_.AddOffset(TosaOperator::VT_QUANT_INFO, quant_info);
2253 }
2254 explicit TosaOperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2255 : fbb_(_fbb) {
2256 start_ = fbb_.StartTable();
2257 }
2258 TosaOperatorBuilder &operator=(const TosaOperatorBuilder &);
2259 flatbuffers::Offset<TosaOperator> Finish() {
2260 const auto end = fbb_.EndTable(start_);
2261 auto o = flatbuffers::Offset<TosaOperator>(end);
2262 return o;
2263 }
2264};
2265
2266inline flatbuffers::Offset<TosaOperator> CreateTosaOperator(
2267 flatbuffers::FlatBufferBuilder &_fbb,
2268 tosa::Op op = tosa::Op_UNKNOWN,
2269 tosa::Attribute attribute_type = tosa::Attribute_NONE,
2270 flatbuffers::Offset<void> attribute = 0,
2271 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0,
2272 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0,
2273 tosa::QuantInfo quant_info_type = tosa::QuantInfo_NONE,
2274 flatbuffers::Offset<void> quant_info = 0) {
2275 TosaOperatorBuilder builder_(_fbb);
2276 builder_.add_quant_info(quant_info);
2277 builder_.add_outputs(outputs);
2278 builder_.add_inputs(inputs);
2279 builder_.add_attribute(attribute);
2280 builder_.add_op(op);
2281 builder_.add_quant_info_type(quant_info_type);
2282 builder_.add_attribute_type(attribute_type);
2283 return builder_.Finish();
2284}
2285
2286inline flatbuffers::Offset<TosaOperator> CreateTosaOperatorDirect(
2287 flatbuffers::FlatBufferBuilder &_fbb,
2288 tosa::Op op = tosa::Op_UNKNOWN,
2289 tosa::Attribute attribute_type = tosa::Attribute_NONE,
2290 flatbuffers::Offset<void> attribute = 0,
2291 const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr,
2292 const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr,
2293 tosa::QuantInfo quant_info_type = tosa::QuantInfo_NONE,
2294 flatbuffers::Offset<void> quant_info = 0) {
2295 auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0;
2296 auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0;
2297 return tosa::CreateTosaOperator(
2298 _fbb,
2299 op,
2300 attribute_type,
2301 attribute,
2302 inputs__,
2303 outputs__,
2304 quant_info_type,
2305 quant_info);
2306}
2307
2308struct TosaBasicBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2309 typedef TosaBasicBlockBuilder Builder;
2310 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2311 VT_NAME = 4,
2312 VT_OPERATORS = 6,
2313 VT_TENSORS = 8,
2314 VT_INPUTS = 10,
2315 VT_OUTPUTS = 12
2316 };
2317 const flatbuffers::String *name() const {
2318 return GetPointer<const flatbuffers::String *>(VT_NAME);
2319 }
2320 const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>> *operators() const {
2321 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>> *>(VT_OPERATORS);
2322 }
2323 const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>> *tensors() const {
2324 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>> *>(VT_TENSORS);
2325 }
2326 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const {
2327 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS);
2328 }
2329 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const {
2330 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS);
2331 }
2332 bool Verify(flatbuffers::Verifier &verifier) const {
2333 return VerifyTableStart(verifier) &&
2334 VerifyOffset(verifier, VT_NAME) &&
2335 verifier.VerifyString(name()) &&
2336 VerifyOffset(verifier, VT_OPERATORS) &&
2337 verifier.VerifyVector(operators()) &&
2338 verifier.VerifyVectorOfTables(operators()) &&
2339 VerifyOffset(verifier, VT_TENSORS) &&
2340 verifier.VerifyVector(tensors()) &&
2341 verifier.VerifyVectorOfTables(tensors()) &&
2342 VerifyOffset(verifier, VT_INPUTS) &&
2343 verifier.VerifyVector(inputs()) &&
2344 verifier.VerifyVectorOfStrings(inputs()) &&
2345 VerifyOffset(verifier, VT_OUTPUTS) &&
2346 verifier.VerifyVector(outputs()) &&
2347 verifier.VerifyVectorOfStrings(outputs()) &&
2348 verifier.EndTable();
2349 }
2350};
2351
2352struct TosaBasicBlockBuilder {
2353 typedef TosaBasicBlock Table;
2354 flatbuffers::FlatBufferBuilder &fbb_;
2355 flatbuffers::uoffset_t start_;
2356 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
2357 fbb_.AddOffset(TosaBasicBlock::VT_NAME, name);
2358 }
2359 void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>>> operators) {
2360 fbb_.AddOffset(TosaBasicBlock::VT_OPERATORS, operators);
2361 }
2362 void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>>> tensors) {
2363 fbb_.AddOffset(TosaBasicBlock::VT_TENSORS, tensors);
2364 }
2365 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) {
2366 fbb_.AddOffset(TosaBasicBlock::VT_INPUTS, inputs);
2367 }
2368 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) {
2369 fbb_.AddOffset(TosaBasicBlock::VT_OUTPUTS, outputs);
2370 }
2371 explicit TosaBasicBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2372 : fbb_(_fbb) {
2373 start_ = fbb_.StartTable();
2374 }
2375 TosaBasicBlockBuilder &operator=(const TosaBasicBlockBuilder &);
2376 flatbuffers::Offset<TosaBasicBlock> Finish() {
2377 const auto end = fbb_.EndTable(start_);
2378 auto o = flatbuffers::Offset<TosaBasicBlock>(end);
2379 return o;
2380 }
2381};
2382
2383inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlock(
2384 flatbuffers::FlatBufferBuilder &_fbb,
2385 flatbuffers::Offset<flatbuffers::String> name = 0,
2386 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>>> operators = 0,
2387 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>>> tensors = 0,
2388 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0,
2389 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0) {
2390 TosaBasicBlockBuilder builder_(_fbb);
2391 builder_.add_outputs(outputs);
2392 builder_.add_inputs(inputs);
2393 builder_.add_tensors(tensors);
2394 builder_.add_operators(operators);
2395 builder_.add_name(name);
2396 return builder_.Finish();
2397}
2398
2399inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlockDirect(
2400 flatbuffers::FlatBufferBuilder &_fbb,
2401 const char *name = nullptr,
2402 const std::vector<flatbuffers::Offset<tosa::TosaOperator>> *operators = nullptr,
2403 const std::vector<flatbuffers::Offset<tosa::TosaTensor>> *tensors = nullptr,
2404 const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr,
2405 const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr) {
2406 auto name__ = name ? _fbb.CreateString(name) : 0;
2407 auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<tosa::TosaOperator>>(*operators) : 0;
2408 auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<tosa::TosaTensor>>(*tensors) : 0;
2409 auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0;
2410 auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0;
2411 return tosa::CreateTosaBasicBlock(
2412 _fbb,
2413 name__,
2414 operators__,
2415 tensors__,
2416 inputs__,
2417 outputs__);
2418}
2419
2420struct TosaGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2421 typedef TosaGraphBuilder Builder;
2422 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2423 VT_VERSION = 4,
2424 VT_BLOCKS = 6
2425 };
2426 const tosa::Version *version() const {
2427 return GetPointer<const tosa::Version *>(VT_VERSION);
2428 }
2429 const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>> *blocks() const {
2430 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>> *>(VT_BLOCKS);
2431 }
2432 bool Verify(flatbuffers::Verifier &verifier) const {
2433 return VerifyTableStart(verifier) &&
2434 VerifyOffset(verifier, VT_VERSION) &&
2435 verifier.VerifyTable(version()) &&
2436 VerifyOffset(verifier, VT_BLOCKS) &&
2437 verifier.VerifyVector(blocks()) &&
2438 verifier.VerifyVectorOfTables(blocks()) &&
2439 verifier.EndTable();
2440 }
2441};
2442
2443struct TosaGraphBuilder {
2444 typedef TosaGraph Table;
2445 flatbuffers::FlatBufferBuilder &fbb_;
2446 flatbuffers::uoffset_t start_;
2447 void add_version(flatbuffers::Offset<tosa::Version> version) {
2448 fbb_.AddOffset(TosaGraph::VT_VERSION, version);
2449 }
2450 void add_blocks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>>> blocks) {
2451 fbb_.AddOffset(TosaGraph::VT_BLOCKS, blocks);
2452 }
2453 explicit TosaGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2454 : fbb_(_fbb) {
2455 start_ = fbb_.StartTable();
2456 }
2457 TosaGraphBuilder &operator=(const TosaGraphBuilder &);
2458 flatbuffers::Offset<TosaGraph> Finish() {
2459 const auto end = fbb_.EndTable(start_);
2460 auto o = flatbuffers::Offset<TosaGraph>(end);
2461 return o;
2462 }
2463};
2464
2465inline flatbuffers::Offset<TosaGraph> CreateTosaGraph(
2466 flatbuffers::FlatBufferBuilder &_fbb,
2467 flatbuffers::Offset<tosa::Version> version = 0,
2468 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>>> blocks = 0) {
2469 TosaGraphBuilder builder_(_fbb);
2470 builder_.add_blocks(blocks);
2471 builder_.add_version(version);
2472 return builder_.Finish();
2473}
2474
2475inline flatbuffers::Offset<TosaGraph> CreateTosaGraphDirect(
2476 flatbuffers::FlatBufferBuilder &_fbb,
2477 flatbuffers::Offset<tosa::Version> version = 0,
2478 const std::vector<flatbuffers::Offset<tosa::TosaBasicBlock>> *blocks = nullptr) {
2479 auto blocks__ = blocks ? _fbb.CreateVector<flatbuffers::Offset<tosa::TosaBasicBlock>>(*blocks) : 0;
2480 return tosa::CreateTosaGraph(
2481 _fbb,
2482 version,
2483 blocks__);
2484}
2485
2486inline bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type) {
2487 switch (type) {
2488 case Attribute_NONE: {
2489 return true;
2490 }
2491 case Attribute_Pool2dAttribute: {
2492 auto ptr = reinterpret_cast<const tosa::Pool2dAttribute *>(obj);
2493 return verifier.VerifyTable(ptr);
2494 }
2495 case Attribute_Conv2dAttribute: {
2496 auto ptr = reinterpret_cast<const tosa::Conv2dAttribute *>(obj);
2497 return verifier.VerifyTable(ptr);
2498 }
2499 case Attribute_TransposeConv2dAttribute: {
2500 auto ptr = reinterpret_cast<const tosa::TransposeConv2dAttribute *>(obj);
2501 return verifier.VerifyTable(ptr);
2502 }
2503 case Attribute_ReluNAttribute: {
2504 auto ptr = reinterpret_cast<const tosa::ReluNAttribute *>(obj);
2505 return verifier.VerifyTable(ptr);
2506 }
2507 case Attribute_AxisAttribute: {
2508 auto ptr = reinterpret_cast<const tosa::AxisAttribute *>(obj);
2509 return verifier.VerifyTable(ptr);
2510 }
2511 case Attribute_ReshapeAttribute: {
2512 auto ptr = reinterpret_cast<const tosa::ReshapeAttribute *>(obj);
2513 return verifier.VerifyTable(ptr);
2514 }
2515 case Attribute_SliceAttribute: {
2516 auto ptr = reinterpret_cast<const tosa::SliceAttribute *>(obj);
2517 return verifier.VerifyTable(ptr);
2518 }
2519 case Attribute_TileAttribute: {
2520 auto ptr = reinterpret_cast<const tosa::TileAttribute *>(obj);
2521 return verifier.VerifyTable(ptr);
2522 }
2523 case Attribute_ResizeAttribute: {
2524 auto ptr = reinterpret_cast<const tosa::ResizeAttribute *>(obj);
2525 return verifier.VerifyTable(ptr);
2526 }
2527 case Attribute_ClampAttribute: {
2528 auto ptr = reinterpret_cast<const tosa::ClampAttribute *>(obj);
2529 return verifier.VerifyTable(ptr);
2530 }
2531 case Attribute_RescaleAttribute: {
2532 auto ptr = reinterpret_cast<const tosa::RescaleAttribute *>(obj);
2533 return verifier.VerifyTable(ptr);
2534 }
2535 case Attribute_MulAttribute: {
2536 auto ptr = reinterpret_cast<const tosa::MulAttribute *>(obj);
2537 return verifier.VerifyTable(ptr);
2538 }
2539 case Attribute_ArithmeticRightShiftAttribute: {
2540 auto ptr = reinterpret_cast<const tosa::ArithmeticRightShiftAttribute *>(obj);
2541 return verifier.VerifyTable(ptr);
2542 }
2543 case Attribute_CondIfAttribute: {
2544 auto ptr = reinterpret_cast<const tosa::CondIfAttribute *>(obj);
2545 return verifier.VerifyTable(ptr);
2546 }
2547 case Attribute_WhileLoopAttribute: {
2548 auto ptr = reinterpret_cast<const tosa::WhileLoopAttribute *>(obj);
2549 return verifier.VerifyTable(ptr);
2550 }
2551 default: return true;
2552 }
2553}
2554
2555inline bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2556 if (!values || !types) return !values && !types;
2557 if (values->size() != types->size()) return false;
2558 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2559 if (!VerifyAttribute(
2560 verifier, values->Get(i), types->GetEnum<Attribute>(i))) {
2561 return false;
2562 }
2563 }
2564 return true;
2565}
2566
2567inline bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type) {
2568 switch (type) {
2569 case QuantInfo_NONE: {
2570 return true;
2571 }
2572 case QuantInfo_UnaryQuantInfo: {
2573 auto ptr = reinterpret_cast<const tosa::UnaryQuantInfo *>(obj);
2574 return verifier.VerifyTable(ptr);
2575 }
2576 case QuantInfo_ConvQuantInfo: {
2577 auto ptr = reinterpret_cast<const tosa::ConvQuantInfo *>(obj);
2578 return verifier.VerifyTable(ptr);
2579 }
2580 case QuantInfo_MatMulQuantInfo: {
2581 auto ptr = reinterpret_cast<const tosa::MatMulQuantInfo *>(obj);
2582 return verifier.VerifyTable(ptr);
2583 }
2584 case QuantInfo_PadQuantInfo: {
2585 auto ptr = reinterpret_cast<const tosa::PadQuantInfo *>(obj);
2586 return verifier.VerifyTable(ptr);
2587 }
2588 default: return true;
2589 }
2590}
2591
2592inline bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2593 if (!values || !types) return !values && !types;
2594 if (values->size() != types->size()) return false;
2595 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2596 if (!VerifyQuantInfo(
2597 verifier, values->Get(i), types->GetEnum<QuantInfo>(i))) {
2598 return false;
2599 }
2600 }
2601 return true;
2602}
2603
2604inline const tosa::TosaGraph *GetTosaGraph(const void *buf) {
2605 return flatbuffers::GetRoot<tosa::TosaGraph>(buf);
2606}
2607
2608inline const tosa::TosaGraph *GetSizePrefixedTosaGraph(const void *buf) {
2609 return flatbuffers::GetSizePrefixedRoot<tosa::TosaGraph>(buf);
2610}
2611
2612inline const char *TosaGraphIdentifier() {
2613 return "TOSA";
2614}
2615
2616inline bool TosaGraphBufferHasIdentifier(const void *buf) {
2617 return flatbuffers::BufferHasIdentifier(
2618 buf, TosaGraphIdentifier());
2619}
2620
2621inline bool VerifyTosaGraphBuffer(
2622 flatbuffers::Verifier &verifier) {
2623 return verifier.VerifyBuffer<tosa::TosaGraph>(TosaGraphIdentifier());
2624}
2625
2626inline bool VerifySizePrefixedTosaGraphBuffer(
2627 flatbuffers::Verifier &verifier) {
2628 return verifier.VerifySizePrefixedBuffer<tosa::TosaGraph>(TosaGraphIdentifier());
2629}
2630
2631inline const char *TosaGraphExtension() {
2632 return "tosa";
2633}
2634
2635inline void FinishTosaGraphBuffer(
2636 flatbuffers::FlatBufferBuilder &fbb,
2637 flatbuffers::Offset<tosa::TosaGraph> root) {
2638 fbb.Finish(root, TosaGraphIdentifier());
2639}
2640
2641inline void FinishSizePrefixedTosaGraphBuffer(
2642 flatbuffers::FlatBufferBuilder &fbb,
2643 flatbuffers::Offset<tosa::TosaGraph> root) {
2644 fbb.FinishSizePrefixed(root, TosaGraphIdentifier());
2645}
2646
2647} // namespace tosa
2648
2649#endif // FLATBUFFERS_GENERATED_TOSA_TOSA_H_