1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_TENSORFLOWOP_MNN_H_
5 #define FLATBUFFERS_GENERATED_TENSORFLOWOP_MNN_H_
6
7
8 #include "Tensor_generated.h"
9 #include "Type_generated.h"
10
11 namespace MNN {
12
13 struct BinaryOp;
14 struct BinaryOpT;
15
16 struct PackParam;
17 struct PackParamT;
18
19 struct StridedSliceParam;
20 struct StridedSliceParamT;
21
22 struct SqueezeParam;
23 struct SqueezeParamT;
24
25 struct CastParam;
26 struct CastParamT;
27
28 struct ReductionParam;
29 struct ReductionParamT;
30
31 struct Gather;
32 struct GatherT;
33
34 struct ExpandDims;
35 struct ExpandDimsT;
36
37 struct Selu;
38 struct SeluT;
39
40 struct AsString;
41 struct AsStringT;
42
43 struct ReduceJoin;
44 struct ReduceJoinT;
45
46 struct UnaryOp;
47 struct UnaryOpT;
48
49 struct TopKV2;
50 struct TopKV2T;
51
52 struct CropAndResize;
53 struct CropAndResizeT;
54
55 struct Fill;
56 struct FillT;
57
58 struct GatherV2;
59 struct GatherV2T;
60
61 struct NonMaxSuppressionV2;
62 struct NonMaxSuppressionV2T;
63
64 struct Range;
65 struct RangeT;
66
67 struct Rank;
68 struct RankT;
69
70 struct Size;
71 struct SizeT;
72
73 struct Transpose;
74 struct TransposeT;
75
76 struct SliceTf;
77 struct SliceTfT;
78
79 struct QuantizeMaxMin;
80 struct QuantizeMaxMinT;
81
82 struct Crop;
83 struct CropT;
84
85 struct SpaceBatch;
86 struct SpaceBatchT;
87
88 struct MatMul;
89 struct MatMulT;
90
91 struct MomentsParam;
92 struct MomentsParamT;
93
94 struct RNNParam;
95 struct RNNParamT;
96
97 struct BatchMatMulParam;
98 struct BatchMatMulParamT;
99
100 struct DepthSpaceParam;
101 struct DepthSpaceParamT;
102
103 struct ReverseSequenceParam;
104 struct ReverseSequenceParamT;
105
106 struct DetectionPostProcessParam;
107 struct DetectionPostProcessParamT;
108
109 struct OneHotParam;
110 struct OneHotParamT;
111
112 struct PadParam;
113 struct PadParamT;
114
115 struct LayerNorm;
116 struct LayerNormT;
117
118 struct RandomUniform;
119 struct RandomUniformT;
120
121 struct TensorArray;
122 struct TensorArrayT;
123
124 struct LSTMBlockCell;
125 struct LSTMBlockCellT;
126
127 inline const flatbuffers::TypeTable *BinaryOpTypeTable();
128
129 inline const flatbuffers::TypeTable *PackParamTypeTable();
130
131 inline const flatbuffers::TypeTable *StridedSliceParamTypeTable();
132
133 inline const flatbuffers::TypeTable *SqueezeParamTypeTable();
134
135 inline const flatbuffers::TypeTable *CastParamTypeTable();
136
137 inline const flatbuffers::TypeTable *ReductionParamTypeTable();
138
139 inline const flatbuffers::TypeTable *GatherTypeTable();
140
141 inline const flatbuffers::TypeTable *ExpandDimsTypeTable();
142
143 inline const flatbuffers::TypeTable *SeluTypeTable();
144
145 inline const flatbuffers::TypeTable *AsStringTypeTable();
146
147 inline const flatbuffers::TypeTable *ReduceJoinTypeTable();
148
149 inline const flatbuffers::TypeTable *UnaryOpTypeTable();
150
151 inline const flatbuffers::TypeTable *TopKV2TypeTable();
152
153 inline const flatbuffers::TypeTable *CropAndResizeTypeTable();
154
155 inline const flatbuffers::TypeTable *FillTypeTable();
156
157 inline const flatbuffers::TypeTable *GatherV2TypeTable();
158
159 inline const flatbuffers::TypeTable *NonMaxSuppressionV2TypeTable();
160
161 inline const flatbuffers::TypeTable *RangeTypeTable();
162
163 inline const flatbuffers::TypeTable *RankTypeTable();
164
165 inline const flatbuffers::TypeTable *SizeTypeTable();
166
167 inline const flatbuffers::TypeTable *TransposeTypeTable();
168
169 inline const flatbuffers::TypeTable *SliceTfTypeTable();
170
171 inline const flatbuffers::TypeTable *QuantizeMaxMinTypeTable();
172
173 inline const flatbuffers::TypeTable *CropTypeTable();
174
175 inline const flatbuffers::TypeTable *SpaceBatchTypeTable();
176
177 inline const flatbuffers::TypeTable *MatMulTypeTable();
178
179 inline const flatbuffers::TypeTable *MomentsParamTypeTable();
180
181 inline const flatbuffers::TypeTable *RNNParamTypeTable();
182
183 inline const flatbuffers::TypeTable *BatchMatMulParamTypeTable();
184
185 inline const flatbuffers::TypeTable *DepthSpaceParamTypeTable();
186
187 inline const flatbuffers::TypeTable *ReverseSequenceParamTypeTable();
188
189 inline const flatbuffers::TypeTable *DetectionPostProcessParamTypeTable();
190
191 inline const flatbuffers::TypeTable *OneHotParamTypeTable();
192
193 inline const flatbuffers::TypeTable *PadParamTypeTable();
194
195 inline const flatbuffers::TypeTable *LayerNormTypeTable();
196
197 inline const flatbuffers::TypeTable *RandomUniformTypeTable();
198
199 inline const flatbuffers::TypeTable *TensorArrayTypeTable();
200
201 inline const flatbuffers::TypeTable *LSTMBlockCellTypeTable();
202
203 enum BinaryOpOperation {
204 BinaryOpOperation_ADD = 0,
205 BinaryOpOperation_SUB = 1,
206 BinaryOpOperation_MUL = 2,
207 BinaryOpOperation_DIV = 3,
208 BinaryOpOperation_MAX_TEMP = 4,
209 BinaryOpOperation_MIN_TEMP = 5,
210 BinaryOpOperation_POW = 6,
211 BinaryOpOperation_REALDIV = 7,
212 BinaryOpOperation_MINIMUM = 8,
213 BinaryOpOperation_MAXIMUM = 9,
214 BinaryOpOperation_GREATER = 10,
215 BinaryOpOperation_GREATER_EQUAL = 11,
216 BinaryOpOperation_LESS = 12,
217 BinaryOpOperation_FLOORDIV = 13,
218 BinaryOpOperation_SquaredDifference = 14,
219 BinaryOpOperation_EQUAL = 15,
220 BinaryOpOperation_LESS_EQUAL = 16,
221 BinaryOpOperation_FLOORMOD = 17,
222 BinaryOpOperation_MOD = 19,
223 BinaryOpOperation_ATAN2 = 20,
224 BinaryOpOperation_LOGICALOR = 21,
225 BinaryOpOperation_NOTEQUAL = 22,
226 BinaryOpOperation_MIN = BinaryOpOperation_ADD,
227 BinaryOpOperation_MAX = BinaryOpOperation_NOTEQUAL
228 };
229
EnumValuesBinaryOpOperation()230 inline const BinaryOpOperation (&EnumValuesBinaryOpOperation())[22] {
231 static const BinaryOpOperation values[] = {
232 BinaryOpOperation_ADD,
233 BinaryOpOperation_SUB,
234 BinaryOpOperation_MUL,
235 BinaryOpOperation_DIV,
236 BinaryOpOperation_MAX_TEMP,
237 BinaryOpOperation_MIN_TEMP,
238 BinaryOpOperation_POW,
239 BinaryOpOperation_REALDIV,
240 BinaryOpOperation_MINIMUM,
241 BinaryOpOperation_MAXIMUM,
242 BinaryOpOperation_GREATER,
243 BinaryOpOperation_GREATER_EQUAL,
244 BinaryOpOperation_LESS,
245 BinaryOpOperation_FLOORDIV,
246 BinaryOpOperation_SquaredDifference,
247 BinaryOpOperation_EQUAL,
248 BinaryOpOperation_LESS_EQUAL,
249 BinaryOpOperation_FLOORMOD,
250 BinaryOpOperation_MOD,
251 BinaryOpOperation_ATAN2,
252 BinaryOpOperation_LOGICALOR,
253 BinaryOpOperation_NOTEQUAL
254 };
255 return values;
256 }
257
EnumNamesBinaryOpOperation()258 inline const char * const *EnumNamesBinaryOpOperation() {
259 static const char * const names[] = {
260 "ADD",
261 "SUB",
262 "MUL",
263 "DIV",
264 "MAX_TEMP",
265 "MIN_TEMP",
266 "POW",
267 "REALDIV",
268 "MINIMUM",
269 "MAXIMUM",
270 "GREATER",
271 "GREATER_EQUAL",
272 "LESS",
273 "FLOORDIV",
274 "SquaredDifference",
275 "EQUAL",
276 "LESS_EQUAL",
277 "FLOORMOD",
278 "",
279 "MOD",
280 "ATAN2",
281 "LOGICALOR",
282 "NOTEQUAL",
283 nullptr
284 };
285 return names;
286 }
287
EnumNameBinaryOpOperation(BinaryOpOperation e)288 inline const char *EnumNameBinaryOpOperation(BinaryOpOperation e) {
289 if (e < BinaryOpOperation_ADD || e > BinaryOpOperation_NOTEQUAL) return "";
290 const size_t index = static_cast<int>(e);
291 return EnumNamesBinaryOpOperation()[index];
292 }
293
294 enum ReductionType {
295 ReductionType_SUM = 0,
296 ReductionType_ASUM = 1,
297 ReductionType_SUMSQ = 2,
298 ReductionType_MEAN = 3,
299 ReductionType_MAXIMUM = 4,
300 ReductionType_MINIMUM = 5,
301 ReductionType_PROD = 6,
302 ReductionType_ANY = 7,
303 ReductionType_ALL = 8,
304 ReductionType_MIN = ReductionType_SUM,
305 ReductionType_MAX = ReductionType_ALL
306 };
307
EnumValuesReductionType()308 inline const ReductionType (&EnumValuesReductionType())[9] {
309 static const ReductionType values[] = {
310 ReductionType_SUM,
311 ReductionType_ASUM,
312 ReductionType_SUMSQ,
313 ReductionType_MEAN,
314 ReductionType_MAXIMUM,
315 ReductionType_MINIMUM,
316 ReductionType_PROD,
317 ReductionType_ANY,
318 ReductionType_ALL
319 };
320 return values;
321 }
322
EnumNamesReductionType()323 inline const char * const *EnumNamesReductionType() {
324 static const char * const names[] = {
325 "SUM",
326 "ASUM",
327 "SUMSQ",
328 "MEAN",
329 "MAXIMUM",
330 "MINIMUM",
331 "PROD",
332 "ANY",
333 "ALL",
334 nullptr
335 };
336 return names;
337 }
338
EnumNameReductionType(ReductionType e)339 inline const char *EnumNameReductionType(ReductionType e) {
340 if (e < ReductionType_SUM || e > ReductionType_ALL) return "";
341 const size_t index = static_cast<int>(e);
342 return EnumNamesReductionType()[index];
343 }
344
345 enum UnaryOpOperation {
346 UnaryOpOperation_ABS = 0,
347 UnaryOpOperation_NEG = 1,
348 UnaryOpOperation_FLOOR = 2,
349 UnaryOpOperation_CEIL = 3,
350 UnaryOpOperation_SQUARE = 4,
351 UnaryOpOperation_SQRT = 5,
352 UnaryOpOperation_RSQRT = 6,
353 UnaryOpOperation_EXP = 7,
354 UnaryOpOperation_LOG = 8,
355 UnaryOpOperation_SIN = 9,
356 UnaryOpOperation_COS = 10,
357 UnaryOpOperation_TAN = 11,
358 UnaryOpOperation_ASIN = 12,
359 UnaryOpOperation_ACOS = 13,
360 UnaryOpOperation_ATAN = 14,
361 UnaryOpOperation_RECIPROCAL = 15,
362 UnaryOpOperation_LOG1P = 16,
363 UnaryOpOperation_BNLL = 17,
364 UnaryOpOperation_ACOSH = 18,
365 UnaryOpOperation_SINH = 19,
366 UnaryOpOperation_ASINH = 20,
367 UnaryOpOperation_ATANH = 21,
368 UnaryOpOperation_SIGN = 22,
369 UnaryOpOperation_ROUND = 23,
370 UnaryOpOperation_COSH = 24,
371 UnaryOpOperation_ERF = 25,
372 UnaryOpOperation_ERFC = 26,
373 UnaryOpOperation_ERFINV = 27,
374 UnaryOpOperation_EXPM1 = 28,
375 UnaryOpOperation_SIGMOID = 29,
376 UnaryOpOperation_TANH = 30,
377 UnaryOpOperation_HARDSWISH = 31,
378 UnaryOpOperation_GELU = 32,
379 UnaryOpOperation_MIN = UnaryOpOperation_ABS,
380 UnaryOpOperation_MAX = UnaryOpOperation_GELU
381 };
382
EnumValuesUnaryOpOperation()383 inline const UnaryOpOperation (&EnumValuesUnaryOpOperation())[33] {
384 static const UnaryOpOperation values[] = {
385 UnaryOpOperation_ABS,
386 UnaryOpOperation_NEG,
387 UnaryOpOperation_FLOOR,
388 UnaryOpOperation_CEIL,
389 UnaryOpOperation_SQUARE,
390 UnaryOpOperation_SQRT,
391 UnaryOpOperation_RSQRT,
392 UnaryOpOperation_EXP,
393 UnaryOpOperation_LOG,
394 UnaryOpOperation_SIN,
395 UnaryOpOperation_COS,
396 UnaryOpOperation_TAN,
397 UnaryOpOperation_ASIN,
398 UnaryOpOperation_ACOS,
399 UnaryOpOperation_ATAN,
400 UnaryOpOperation_RECIPROCAL,
401 UnaryOpOperation_LOG1P,
402 UnaryOpOperation_BNLL,
403 UnaryOpOperation_ACOSH,
404 UnaryOpOperation_SINH,
405 UnaryOpOperation_ASINH,
406 UnaryOpOperation_ATANH,
407 UnaryOpOperation_SIGN,
408 UnaryOpOperation_ROUND,
409 UnaryOpOperation_COSH,
410 UnaryOpOperation_ERF,
411 UnaryOpOperation_ERFC,
412 UnaryOpOperation_ERFINV,
413 UnaryOpOperation_EXPM1,
414 UnaryOpOperation_SIGMOID,
415 UnaryOpOperation_TANH,
416 UnaryOpOperation_HARDSWISH,
417 UnaryOpOperation_GELU
418 };
419 return values;
420 }
421
EnumNamesUnaryOpOperation()422 inline const char * const *EnumNamesUnaryOpOperation() {
423 static const char * const names[] = {
424 "ABS",
425 "NEG",
426 "FLOOR",
427 "CEIL",
428 "SQUARE",
429 "SQRT",
430 "RSQRT",
431 "EXP",
432 "LOG",
433 "SIN",
434 "COS",
435 "TAN",
436 "ASIN",
437 "ACOS",
438 "ATAN",
439 "RECIPROCAL",
440 "LOG1P",
441 "BNLL",
442 "ACOSH",
443 "SINH",
444 "ASINH",
445 "ATANH",
446 "SIGN",
447 "ROUND",
448 "COSH",
449 "ERF",
450 "ERFC",
451 "ERFINV",
452 "EXPM1",
453 "SIGMOID",
454 "TANH",
455 "HARDSWISH",
456 "GELU",
457 nullptr
458 };
459 return names;
460 }
461
EnumNameUnaryOpOperation(UnaryOpOperation e)462 inline const char *EnumNameUnaryOpOperation(UnaryOpOperation e) {
463 if (e < UnaryOpOperation_ABS || e > UnaryOpOperation_GELU) return "";
464 const size_t index = static_cast<int>(e);
465 return EnumNamesUnaryOpOperation()[index];
466 }
467
468 enum CropAndResizeMethod {
469 CropAndResizeMethod_BILINEAR = 0,
470 CropAndResizeMethod_NEAREST = 1,
471 CropAndResizeMethod_MIN = CropAndResizeMethod_BILINEAR,
472 CropAndResizeMethod_MAX = CropAndResizeMethod_NEAREST
473 };
474
EnumValuesCropAndResizeMethod()475 inline const CropAndResizeMethod (&EnumValuesCropAndResizeMethod())[2] {
476 static const CropAndResizeMethod values[] = {
477 CropAndResizeMethod_BILINEAR,
478 CropAndResizeMethod_NEAREST
479 };
480 return values;
481 }
482
EnumNamesCropAndResizeMethod()483 inline const char * const *EnumNamesCropAndResizeMethod() {
484 static const char * const names[] = {
485 "BILINEAR",
486 "NEAREST",
487 nullptr
488 };
489 return names;
490 }
491
EnumNameCropAndResizeMethod(CropAndResizeMethod e)492 inline const char *EnumNameCropAndResizeMethod(CropAndResizeMethod e) {
493 if (e < CropAndResizeMethod_BILINEAR || e > CropAndResizeMethod_NEAREST) return "";
494 const size_t index = static_cast<int>(e);
495 return EnumNamesCropAndResizeMethod()[index];
496 }
497
498 enum DepthToSpaceMode {
499 DepthToSpaceMode_DCR = 0,
500 DepthToSpaceMode_CRD = 1,
501 DepthToSpaceMode_MIN = DepthToSpaceMode_DCR,
502 DepthToSpaceMode_MAX = DepthToSpaceMode_CRD
503 };
504
EnumValuesDepthToSpaceMode()505 inline const DepthToSpaceMode (&EnumValuesDepthToSpaceMode())[2] {
506 static const DepthToSpaceMode values[] = {
507 DepthToSpaceMode_DCR,
508 DepthToSpaceMode_CRD
509 };
510 return values;
511 }
512
EnumNamesDepthToSpaceMode()513 inline const char * const *EnumNamesDepthToSpaceMode() {
514 static const char * const names[] = {
515 "DCR",
516 "CRD",
517 nullptr
518 };
519 return names;
520 }
521
EnumNameDepthToSpaceMode(DepthToSpaceMode e)522 inline const char *EnumNameDepthToSpaceMode(DepthToSpaceMode e) {
523 if (e < DepthToSpaceMode_DCR || e > DepthToSpaceMode_CRD) return "";
524 const size_t index = static_cast<int>(e);
525 return EnumNamesDepthToSpaceMode()[index];
526 }
527
528 enum PadValueMode {
529 PadValueMode_CONSTANT = 0,
530 PadValueMode_REFLECT = 1,
531 PadValueMode_SYMMETRIC = 2,
532 PadValueMode_MIN = PadValueMode_CONSTANT,
533 PadValueMode_MAX = PadValueMode_SYMMETRIC
534 };
535
EnumValuesPadValueMode()536 inline const PadValueMode (&EnumValuesPadValueMode())[3] {
537 static const PadValueMode values[] = {
538 PadValueMode_CONSTANT,
539 PadValueMode_REFLECT,
540 PadValueMode_SYMMETRIC
541 };
542 return values;
543 }
544
EnumNamesPadValueMode()545 inline const char * const *EnumNamesPadValueMode() {
546 static const char * const names[] = {
547 "CONSTANT",
548 "REFLECT",
549 "SYMMETRIC",
550 nullptr
551 };
552 return names;
553 }
554
EnumNamePadValueMode(PadValueMode e)555 inline const char *EnumNamePadValueMode(PadValueMode e) {
556 if (e < PadValueMode_CONSTANT || e > PadValueMode_SYMMETRIC) return "";
557 const size_t index = static_cast<int>(e);
558 return EnumNamesPadValueMode()[index];
559 }
560
561 struct BinaryOpT : public flatbuffers::NativeTable {
562 typedef BinaryOp TableType;
563 int32_t opType;
564 DataType T;
BinaryOpTBinaryOpT565 BinaryOpT()
566 : opType(0),
567 T(DataType_DT_FLOAT) {
568 }
569 };
570
571 struct BinaryOp FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
572 typedef BinaryOpT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS573 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
574 return BinaryOpTypeTable();
575 }
opTypeFLATBUFFERS_FINAL_CLASS576 int32_t opType() const {
577 return GetField<int32_t>(4, 0);
578 }
TFLATBUFFERS_FINAL_CLASS579 DataType T() const {
580 return static_cast<DataType>(GetField<int32_t>(6, 1));
581 }
VerifyFLATBUFFERS_FINAL_CLASS582 bool Verify(flatbuffers::Verifier &verifier) const {
583 return VerifyTableStart(verifier) &&
584 VerifyField<int32_t>(verifier, 4) &&
585 VerifyField<int32_t>(verifier, 6) &&
586 verifier.EndTable();
587 }
588 BinaryOpT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
589 void UnPackTo(BinaryOpT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
590 static flatbuffers::Offset<BinaryOp> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BinaryOpT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
591 };
592
593 struct BinaryOpBuilder {
594 flatbuffers::FlatBufferBuilder &fbb_;
595 flatbuffers::uoffset_t start_;
add_opTypeBinaryOpBuilder596 void add_opType(int32_t opType) {
597 fbb_.AddElement<int32_t>(4, opType, 0);
598 }
add_TBinaryOpBuilder599 void add_T(DataType T) {
600 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(T), 1);
601 }
BinaryOpBuilderBinaryOpBuilder602 explicit BinaryOpBuilder(flatbuffers::FlatBufferBuilder &_fbb)
603 : fbb_(_fbb) {
604 start_ = fbb_.StartTable();
605 }
606 BinaryOpBuilder &operator=(const BinaryOpBuilder &);
FinishBinaryOpBuilder607 flatbuffers::Offset<BinaryOp> Finish() {
608 const auto end = fbb_.EndTable(start_);
609 auto o = flatbuffers::Offset<BinaryOp>(end);
610 return o;
611 }
612 };
613
614 inline flatbuffers::Offset<BinaryOp> CreateBinaryOp(
615 flatbuffers::FlatBufferBuilder &_fbb,
616 int32_t opType = 0,
617 DataType T = DataType_DT_FLOAT) {
618 BinaryOpBuilder builder_(_fbb);
619 builder_.add_T(T);
620 builder_.add_opType(opType);
621 return builder_.Finish();
622 }
623
624 flatbuffers::Offset<BinaryOp> CreateBinaryOp(flatbuffers::FlatBufferBuilder &_fbb, const BinaryOpT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
625
626 struct PackParamT : public flatbuffers::NativeTable {
627 typedef PackParam TableType;
628 DataType dataType;
629 int32_t axis;
PackParamTPackParamT630 PackParamT()
631 : dataType(DataType_DT_INVALID),
632 axis(0) {
633 }
634 };
635
636 struct PackParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
637 typedef PackParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS638 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
639 return PackParamTypeTable();
640 }
dataTypeFLATBUFFERS_FINAL_CLASS641 DataType dataType() const {
642 return static_cast<DataType>(GetField<int32_t>(4, 0));
643 }
axisFLATBUFFERS_FINAL_CLASS644 int32_t axis() const {
645 return GetField<int32_t>(6, 0);
646 }
VerifyFLATBUFFERS_FINAL_CLASS647 bool Verify(flatbuffers::Verifier &verifier) const {
648 return VerifyTableStart(verifier) &&
649 VerifyField<int32_t>(verifier, 4) &&
650 VerifyField<int32_t>(verifier, 6) &&
651 verifier.EndTable();
652 }
653 PackParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
654 void UnPackTo(PackParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
655 static flatbuffers::Offset<PackParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
656 };
657
658 struct PackParamBuilder {
659 flatbuffers::FlatBufferBuilder &fbb_;
660 flatbuffers::uoffset_t start_;
add_dataTypePackParamBuilder661 void add_dataType(DataType dataType) {
662 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(dataType), 0);
663 }
add_axisPackParamBuilder664 void add_axis(int32_t axis) {
665 fbb_.AddElement<int32_t>(6, axis, 0);
666 }
PackParamBuilderPackParamBuilder667 explicit PackParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
668 : fbb_(_fbb) {
669 start_ = fbb_.StartTable();
670 }
671 PackParamBuilder &operator=(const PackParamBuilder &);
FinishPackParamBuilder672 flatbuffers::Offset<PackParam> Finish() {
673 const auto end = fbb_.EndTable(start_);
674 auto o = flatbuffers::Offset<PackParam>(end);
675 return o;
676 }
677 };
678
679 inline flatbuffers::Offset<PackParam> CreatePackParam(
680 flatbuffers::FlatBufferBuilder &_fbb,
681 DataType dataType = DataType_DT_INVALID,
682 int32_t axis = 0) {
683 PackParamBuilder builder_(_fbb);
684 builder_.add_axis(axis);
685 builder_.add_dataType(dataType);
686 return builder_.Finish();
687 }
688
689 flatbuffers::Offset<PackParam> CreatePackParam(flatbuffers::FlatBufferBuilder &_fbb, const PackParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
690
691 struct StridedSliceParamT : public flatbuffers::NativeTable {
692 typedef StridedSliceParam TableType;
693 DataType Index;
694 DataType T;
695 int32_t beginMask;
696 int32_t endMask;
697 int32_t ellipsisMask;
698 int32_t newAxisMask;
699 int32_t shrinkAxisMask;
StridedSliceParamTStridedSliceParamT700 StridedSliceParamT()
701 : Index(DataType_DT_INVALID),
702 T(DataType_DT_INVALID),
703 beginMask(0),
704 endMask(0),
705 ellipsisMask(0),
706 newAxisMask(0),
707 shrinkAxisMask(0) {
708 }
709 };
710
711 struct StridedSliceParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
712 typedef StridedSliceParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS713 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
714 return StridedSliceParamTypeTable();
715 }
IndexFLATBUFFERS_FINAL_CLASS716 DataType Index() const {
717 return static_cast<DataType>(GetField<int32_t>(4, 0));
718 }
TFLATBUFFERS_FINAL_CLASS719 DataType T() const {
720 return static_cast<DataType>(GetField<int32_t>(6, 0));
721 }
beginMaskFLATBUFFERS_FINAL_CLASS722 int32_t beginMask() const {
723 return GetField<int32_t>(8, 0);
724 }
endMaskFLATBUFFERS_FINAL_CLASS725 int32_t endMask() const {
726 return GetField<int32_t>(10, 0);
727 }
ellipsisMaskFLATBUFFERS_FINAL_CLASS728 int32_t ellipsisMask() const {
729 return GetField<int32_t>(12, 0);
730 }
newAxisMaskFLATBUFFERS_FINAL_CLASS731 int32_t newAxisMask() const {
732 return GetField<int32_t>(14, 0);
733 }
shrinkAxisMaskFLATBUFFERS_FINAL_CLASS734 int32_t shrinkAxisMask() const {
735 return GetField<int32_t>(16, 0);
736 }
VerifyFLATBUFFERS_FINAL_CLASS737 bool Verify(flatbuffers::Verifier &verifier) const {
738 return VerifyTableStart(verifier) &&
739 VerifyField<int32_t>(verifier, 4) &&
740 VerifyField<int32_t>(verifier, 6) &&
741 VerifyField<int32_t>(verifier, 8) &&
742 VerifyField<int32_t>(verifier, 10) &&
743 VerifyField<int32_t>(verifier, 12) &&
744 VerifyField<int32_t>(verifier, 14) &&
745 VerifyField<int32_t>(verifier, 16) &&
746 verifier.EndTable();
747 }
748 StridedSliceParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
749 void UnPackTo(StridedSliceParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
750 static flatbuffers::Offset<StridedSliceParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
751 };
752
753 struct StridedSliceParamBuilder {
754 flatbuffers::FlatBufferBuilder &fbb_;
755 flatbuffers::uoffset_t start_;
add_IndexStridedSliceParamBuilder756 void add_Index(DataType Index) {
757 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(Index), 0);
758 }
add_TStridedSliceParamBuilder759 void add_T(DataType T) {
760 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(T), 0);
761 }
add_beginMaskStridedSliceParamBuilder762 void add_beginMask(int32_t beginMask) {
763 fbb_.AddElement<int32_t>(8, beginMask, 0);
764 }
add_endMaskStridedSliceParamBuilder765 void add_endMask(int32_t endMask) {
766 fbb_.AddElement<int32_t>(10, endMask, 0);
767 }
add_ellipsisMaskStridedSliceParamBuilder768 void add_ellipsisMask(int32_t ellipsisMask) {
769 fbb_.AddElement<int32_t>(12, ellipsisMask, 0);
770 }
add_newAxisMaskStridedSliceParamBuilder771 void add_newAxisMask(int32_t newAxisMask) {
772 fbb_.AddElement<int32_t>(14, newAxisMask, 0);
773 }
add_shrinkAxisMaskStridedSliceParamBuilder774 void add_shrinkAxisMask(int32_t shrinkAxisMask) {
775 fbb_.AddElement<int32_t>(16, shrinkAxisMask, 0);
776 }
StridedSliceParamBuilderStridedSliceParamBuilder777 explicit StridedSliceParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
778 : fbb_(_fbb) {
779 start_ = fbb_.StartTable();
780 }
781 StridedSliceParamBuilder &operator=(const StridedSliceParamBuilder &);
FinishStridedSliceParamBuilder782 flatbuffers::Offset<StridedSliceParam> Finish() {
783 const auto end = fbb_.EndTable(start_);
784 auto o = flatbuffers::Offset<StridedSliceParam>(end);
785 return o;
786 }
787 };
788
789 inline flatbuffers::Offset<StridedSliceParam> CreateStridedSliceParam(
790 flatbuffers::FlatBufferBuilder &_fbb,
791 DataType Index = DataType_DT_INVALID,
792 DataType T = DataType_DT_INVALID,
793 int32_t beginMask = 0,
794 int32_t endMask = 0,
795 int32_t ellipsisMask = 0,
796 int32_t newAxisMask = 0,
797 int32_t shrinkAxisMask = 0) {
798 StridedSliceParamBuilder builder_(_fbb);
799 builder_.add_shrinkAxisMask(shrinkAxisMask);
800 builder_.add_newAxisMask(newAxisMask);
801 builder_.add_ellipsisMask(ellipsisMask);
802 builder_.add_endMask(endMask);
803 builder_.add_beginMask(beginMask);
804 builder_.add_T(T);
805 builder_.add_Index(Index);
806 return builder_.Finish();
807 }
808
809 flatbuffers::Offset<StridedSliceParam> CreateStridedSliceParam(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
810
811 struct SqueezeParamT : public flatbuffers::NativeTable {
812 typedef SqueezeParam TableType;
813 std::vector<int32_t> squeezeDims;
SqueezeParamTSqueezeParamT814 SqueezeParamT() {
815 }
816 };
817
818 struct SqueezeParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
819 typedef SqueezeParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS820 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
821 return SqueezeParamTypeTable();
822 }
squeezeDimsFLATBUFFERS_FINAL_CLASS823 const flatbuffers::Vector<int32_t> *squeezeDims() const {
824 return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
825 }
VerifyFLATBUFFERS_FINAL_CLASS826 bool Verify(flatbuffers::Verifier &verifier) const {
827 return VerifyTableStart(verifier) &&
828 VerifyOffset(verifier, 4) &&
829 verifier.VerifyVector(squeezeDims()) &&
830 verifier.EndTable();
831 }
832 SqueezeParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
833 void UnPackTo(SqueezeParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
834 static flatbuffers::Offset<SqueezeParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
835 };
836
837 struct SqueezeParamBuilder {
838 flatbuffers::FlatBufferBuilder &fbb_;
839 flatbuffers::uoffset_t start_;
add_squeezeDimsSqueezeParamBuilder840 void add_squeezeDims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeezeDims) {
841 fbb_.AddOffset(4, squeezeDims);
842 }
SqueezeParamBuilderSqueezeParamBuilder843 explicit SqueezeParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
844 : fbb_(_fbb) {
845 start_ = fbb_.StartTable();
846 }
847 SqueezeParamBuilder &operator=(const SqueezeParamBuilder &);
FinishSqueezeParamBuilder848 flatbuffers::Offset<SqueezeParam> Finish() {
849 const auto end = fbb_.EndTable(start_);
850 auto o = flatbuffers::Offset<SqueezeParam>(end);
851 return o;
852 }
853 };
854
855 inline flatbuffers::Offset<SqueezeParam> CreateSqueezeParam(
856 flatbuffers::FlatBufferBuilder &_fbb,
857 flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeezeDims = 0) {
858 SqueezeParamBuilder builder_(_fbb);
859 builder_.add_squeezeDims(squeezeDims);
860 return builder_.Finish();
861 }
862
863 flatbuffers::Offset<SqueezeParam> CreateSqueezeParam(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
864
865 struct CastParamT : public flatbuffers::NativeTable {
866 typedef CastParam TableType;
867 DataType srcT;
868 DataType dstT;
CastParamTCastParamT869 CastParamT()
870 : srcT(DataType_DT_INVALID),
871 dstT(DataType_DT_INVALID) {
872 }
873 };
874
875 struct CastParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
876 typedef CastParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS877 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
878 return CastParamTypeTable();
879 }
srcTFLATBUFFERS_FINAL_CLASS880 DataType srcT() const {
881 return static_cast<DataType>(GetField<int32_t>(4, 0));
882 }
dstTFLATBUFFERS_FINAL_CLASS883 DataType dstT() const {
884 return static_cast<DataType>(GetField<int32_t>(6, 0));
885 }
VerifyFLATBUFFERS_FINAL_CLASS886 bool Verify(flatbuffers::Verifier &verifier) const {
887 return VerifyTableStart(verifier) &&
888 VerifyField<int32_t>(verifier, 4) &&
889 VerifyField<int32_t>(verifier, 6) &&
890 verifier.EndTable();
891 }
892 CastParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
893 void UnPackTo(CastParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
894 static flatbuffers::Offset<CastParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
895 };
896
897 struct CastParamBuilder {
898 flatbuffers::FlatBufferBuilder &fbb_;
899 flatbuffers::uoffset_t start_;
add_srcTCastParamBuilder900 void add_srcT(DataType srcT) {
901 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(srcT), 0);
902 }
add_dstTCastParamBuilder903 void add_dstT(DataType dstT) {
904 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(dstT), 0);
905 }
CastParamBuilderCastParamBuilder906 explicit CastParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
907 : fbb_(_fbb) {
908 start_ = fbb_.StartTable();
909 }
910 CastParamBuilder &operator=(const CastParamBuilder &);
FinishCastParamBuilder911 flatbuffers::Offset<CastParam> Finish() {
912 const auto end = fbb_.EndTable(start_);
913 auto o = flatbuffers::Offset<CastParam>(end);
914 return o;
915 }
916 };
917
918 inline flatbuffers::Offset<CastParam> CreateCastParam(
919 flatbuffers::FlatBufferBuilder &_fbb,
920 DataType srcT = DataType_DT_INVALID,
921 DataType dstT = DataType_DT_INVALID) {
922 CastParamBuilder builder_(_fbb);
923 builder_.add_dstT(dstT);
924 builder_.add_srcT(srcT);
925 return builder_.Finish();
926 }
927
928 flatbuffers::Offset<CastParam> CreateCastParam(flatbuffers::FlatBufferBuilder &_fbb, const CastParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
929
930 struct ReductionParamT : public flatbuffers::NativeTable {
931 typedef ReductionParam TableType;
932 ReductionType operation;
933 std::vector<int32_t> dim;
934 float coeff;
935 bool keepDims;
936 DataType dType;
ReductionParamTReductionParamT937 ReductionParamT()
938 : operation(ReductionType_SUM),
939 coeff(0.0f),
940 keepDims(false),
941 dType(DataType_DT_FLOAT) {
942 }
943 };
944
945 struct ReductionParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
946 typedef ReductionParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS947 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
948 return ReductionParamTypeTable();
949 }
operationFLATBUFFERS_FINAL_CLASS950 ReductionType operation() const {
951 return static_cast<ReductionType>(GetField<int8_t>(4, 0));
952 }
dimFLATBUFFERS_FINAL_CLASS953 const flatbuffers::Vector<int32_t> *dim() const {
954 return GetPointer<const flatbuffers::Vector<int32_t> *>(6);
955 }
coeffFLATBUFFERS_FINAL_CLASS956 float coeff() const {
957 return GetField<float>(8, 0.0f);
958 }
keepDimsFLATBUFFERS_FINAL_CLASS959 bool keepDims() const {
960 return GetField<uint8_t>(10, 0) != 0;
961 }
dTypeFLATBUFFERS_FINAL_CLASS962 DataType dType() const {
963 return static_cast<DataType>(GetField<int32_t>(12, 1));
964 }
VerifyFLATBUFFERS_FINAL_CLASS965 bool Verify(flatbuffers::Verifier &verifier) const {
966 return VerifyTableStart(verifier) &&
967 VerifyField<int8_t>(verifier, 4) &&
968 VerifyOffset(verifier, 6) &&
969 verifier.VerifyVector(dim()) &&
970 VerifyField<float>(verifier, 8) &&
971 VerifyField<uint8_t>(verifier, 10) &&
972 VerifyField<int32_t>(verifier, 12) &&
973 verifier.EndTable();
974 }
975 ReductionParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
976 void UnPackTo(ReductionParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
977 static flatbuffers::Offset<ReductionParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReductionParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
978 };
979
980 struct ReductionParamBuilder {
981 flatbuffers::FlatBufferBuilder &fbb_;
982 flatbuffers::uoffset_t start_;
add_operationReductionParamBuilder983 void add_operation(ReductionType operation) {
984 fbb_.AddElement<int8_t>(4, static_cast<int8_t>(operation), 0);
985 }
add_dimReductionParamBuilder986 void add_dim(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dim) {
987 fbb_.AddOffset(6, dim);
988 }
add_coeffReductionParamBuilder989 void add_coeff(float coeff) {
990 fbb_.AddElement<float>(8, coeff, 0.0f);
991 }
add_keepDimsReductionParamBuilder992 void add_keepDims(bool keepDims) {
993 fbb_.AddElement<uint8_t>(10, static_cast<uint8_t>(keepDims), 0);
994 }
add_dTypeReductionParamBuilder995 void add_dType(DataType dType) {
996 fbb_.AddElement<int32_t>(12, static_cast<int32_t>(dType), 1);
997 }
ReductionParamBuilderReductionParamBuilder998 explicit ReductionParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
999 : fbb_(_fbb) {
1000 start_ = fbb_.StartTable();
1001 }
1002 ReductionParamBuilder &operator=(const ReductionParamBuilder &);
FinishReductionParamBuilder1003 flatbuffers::Offset<ReductionParam> Finish() {
1004 const auto end = fbb_.EndTable(start_);
1005 auto o = flatbuffers::Offset<ReductionParam>(end);
1006 return o;
1007 }
1008 };
1009
1010 inline flatbuffers::Offset<ReductionParam> CreateReductionParam(
1011 flatbuffers::FlatBufferBuilder &_fbb,
1012 ReductionType operation = ReductionType_SUM,
1013 flatbuffers::Offset<flatbuffers::Vector<int32_t>> dim = 0,
1014 float coeff = 0.0f,
1015 bool keepDims = false,
1016 DataType dType = DataType_DT_FLOAT) {
1017 ReductionParamBuilder builder_(_fbb);
1018 builder_.add_dType(dType);
1019 builder_.add_coeff(coeff);
1020 builder_.add_dim(dim);
1021 builder_.add_keepDims(keepDims);
1022 builder_.add_operation(operation);
1023 return builder_.Finish();
1024 }
1025
1026 flatbuffers::Offset<ReductionParam> CreateReductionParam(flatbuffers::FlatBufferBuilder &_fbb, const ReductionParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1027
1028 struct GatherT : public flatbuffers::NativeTable {
1029 typedef Gather TableType;
1030 DataType Tindices;
1031 DataType Tparams;
1032 bool validateIndices;
1033 int32_t axis;
GatherTGatherT1034 GatherT()
1035 : Tindices(DataType_DT_INVALID),
1036 Tparams(DataType_DT_INVALID),
1037 validateIndices(false),
1038 axis(0) {
1039 }
1040 };
1041
1042 struct Gather FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1043 typedef GatherT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1044 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1045 return GatherTypeTable();
1046 }
TindicesFLATBUFFERS_FINAL_CLASS1047 DataType Tindices() const {
1048 return static_cast<DataType>(GetField<int32_t>(4, 0));
1049 }
TparamsFLATBUFFERS_FINAL_CLASS1050 DataType Tparams() const {
1051 return static_cast<DataType>(GetField<int32_t>(6, 0));
1052 }
validateIndicesFLATBUFFERS_FINAL_CLASS1053 bool validateIndices() const {
1054 return GetField<uint8_t>(8, 0) != 0;
1055 }
axisFLATBUFFERS_FINAL_CLASS1056 int32_t axis() const {
1057 return GetField<int32_t>(10, 0);
1058 }
VerifyFLATBUFFERS_FINAL_CLASS1059 bool Verify(flatbuffers::Verifier &verifier) const {
1060 return VerifyTableStart(verifier) &&
1061 VerifyField<int32_t>(verifier, 4) &&
1062 VerifyField<int32_t>(verifier, 6) &&
1063 VerifyField<uint8_t>(verifier, 8) &&
1064 VerifyField<int32_t>(verifier, 10) &&
1065 verifier.EndTable();
1066 }
1067 GatherT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1068 void UnPackTo(GatherT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1069 static flatbuffers::Offset<Gather> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1070 };
1071
1072 struct GatherBuilder {
1073 flatbuffers::FlatBufferBuilder &fbb_;
1074 flatbuffers::uoffset_t start_;
add_TindicesGatherBuilder1075 void add_Tindices(DataType Tindices) {
1076 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(Tindices), 0);
1077 }
add_TparamsGatherBuilder1078 void add_Tparams(DataType Tparams) {
1079 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(Tparams), 0);
1080 }
add_validateIndicesGatherBuilder1081 void add_validateIndices(bool validateIndices) {
1082 fbb_.AddElement<uint8_t>(8, static_cast<uint8_t>(validateIndices), 0);
1083 }
add_axisGatherBuilder1084 void add_axis(int32_t axis) {
1085 fbb_.AddElement<int32_t>(10, axis, 0);
1086 }
GatherBuilderGatherBuilder1087 explicit GatherBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1088 : fbb_(_fbb) {
1089 start_ = fbb_.StartTable();
1090 }
1091 GatherBuilder &operator=(const GatherBuilder &);
FinishGatherBuilder1092 flatbuffers::Offset<Gather> Finish() {
1093 const auto end = fbb_.EndTable(start_);
1094 auto o = flatbuffers::Offset<Gather>(end);
1095 return o;
1096 }
1097 };
1098
1099 inline flatbuffers::Offset<Gather> CreateGather(
1100 flatbuffers::FlatBufferBuilder &_fbb,
1101 DataType Tindices = DataType_DT_INVALID,
1102 DataType Tparams = DataType_DT_INVALID,
1103 bool validateIndices = false,
1104 int32_t axis = 0) {
1105 GatherBuilder builder_(_fbb);
1106 builder_.add_axis(axis);
1107 builder_.add_Tparams(Tparams);
1108 builder_.add_Tindices(Tindices);
1109 builder_.add_validateIndices(validateIndices);
1110 return builder_.Finish();
1111 }
1112
1113 flatbuffers::Offset<Gather> CreateGather(flatbuffers::FlatBufferBuilder &_fbb, const GatherT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1114
1115 struct ExpandDimsT : public flatbuffers::NativeTable {
1116 typedef ExpandDims TableType;
1117 DataType T;
1118 DataType Tdim;
1119 int32_t axis;
ExpandDimsTExpandDimsT1120 ExpandDimsT()
1121 : T(DataType_DT_INVALID),
1122 Tdim(DataType_DT_INVALID),
1123 axis(0) {
1124 }
1125 };
1126
1127 struct ExpandDims FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1128 typedef ExpandDimsT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1129 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1130 return ExpandDimsTypeTable();
1131 }
TFLATBUFFERS_FINAL_CLASS1132 DataType T() const {
1133 return static_cast<DataType>(GetField<int32_t>(4, 0));
1134 }
TdimFLATBUFFERS_FINAL_CLASS1135 DataType Tdim() const {
1136 return static_cast<DataType>(GetField<int32_t>(6, 0));
1137 }
axisFLATBUFFERS_FINAL_CLASS1138 int32_t axis() const {
1139 return GetField<int32_t>(8, 0);
1140 }
VerifyFLATBUFFERS_FINAL_CLASS1141 bool Verify(flatbuffers::Verifier &verifier) const {
1142 return VerifyTableStart(verifier) &&
1143 VerifyField<int32_t>(verifier, 4) &&
1144 VerifyField<int32_t>(verifier, 6) &&
1145 VerifyField<int32_t>(verifier, 8) &&
1146 verifier.EndTable();
1147 }
1148 ExpandDimsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1149 void UnPackTo(ExpandDimsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1150 static flatbuffers::Offset<ExpandDims> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1151 };
1152
1153 struct ExpandDimsBuilder {
1154 flatbuffers::FlatBufferBuilder &fbb_;
1155 flatbuffers::uoffset_t start_;
add_TExpandDimsBuilder1156 void add_T(DataType T) {
1157 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(T), 0);
1158 }
add_TdimExpandDimsBuilder1159 void add_Tdim(DataType Tdim) {
1160 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(Tdim), 0);
1161 }
add_axisExpandDimsBuilder1162 void add_axis(int32_t axis) {
1163 fbb_.AddElement<int32_t>(8, axis, 0);
1164 }
ExpandDimsBuilderExpandDimsBuilder1165 explicit ExpandDimsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1166 : fbb_(_fbb) {
1167 start_ = fbb_.StartTable();
1168 }
1169 ExpandDimsBuilder &operator=(const ExpandDimsBuilder &);
FinishExpandDimsBuilder1170 flatbuffers::Offset<ExpandDims> Finish() {
1171 const auto end = fbb_.EndTable(start_);
1172 auto o = flatbuffers::Offset<ExpandDims>(end);
1173 return o;
1174 }
1175 };
1176
1177 inline flatbuffers::Offset<ExpandDims> CreateExpandDims(
1178 flatbuffers::FlatBufferBuilder &_fbb,
1179 DataType T = DataType_DT_INVALID,
1180 DataType Tdim = DataType_DT_INVALID,
1181 int32_t axis = 0) {
1182 ExpandDimsBuilder builder_(_fbb);
1183 builder_.add_axis(axis);
1184 builder_.add_Tdim(Tdim);
1185 builder_.add_T(T);
1186 return builder_.Finish();
1187 }
1188
1189 flatbuffers::Offset<ExpandDims> CreateExpandDims(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1190
1191 struct SeluT : public flatbuffers::NativeTable {
1192 typedef Selu TableType;
1193 float scale;
1194 float alpha;
SeluTSeluT1195 SeluT()
1196 : scale(0.0f),
1197 alpha(0.0f) {
1198 }
1199 };
1200
1201 struct Selu FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1202 typedef SeluT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1203 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1204 return SeluTypeTable();
1205 }
scaleFLATBUFFERS_FINAL_CLASS1206 float scale() const {
1207 return GetField<float>(4, 0.0f);
1208 }
alphaFLATBUFFERS_FINAL_CLASS1209 float alpha() const {
1210 return GetField<float>(6, 0.0f);
1211 }
VerifyFLATBUFFERS_FINAL_CLASS1212 bool Verify(flatbuffers::Verifier &verifier) const {
1213 return VerifyTableStart(verifier) &&
1214 VerifyField<float>(verifier, 4) &&
1215 VerifyField<float>(verifier, 6) &&
1216 verifier.EndTable();
1217 }
1218 SeluT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1219 void UnPackTo(SeluT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1220 static flatbuffers::Offset<Selu> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SeluT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1221 };
1222
1223 struct SeluBuilder {
1224 flatbuffers::FlatBufferBuilder &fbb_;
1225 flatbuffers::uoffset_t start_;
add_scaleSeluBuilder1226 void add_scale(float scale) {
1227 fbb_.AddElement<float>(4, scale, 0.0f);
1228 }
add_alphaSeluBuilder1229 void add_alpha(float alpha) {
1230 fbb_.AddElement<float>(6, alpha, 0.0f);
1231 }
SeluBuilderSeluBuilder1232 explicit SeluBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1233 : fbb_(_fbb) {
1234 start_ = fbb_.StartTable();
1235 }
1236 SeluBuilder &operator=(const SeluBuilder &);
FinishSeluBuilder1237 flatbuffers::Offset<Selu> Finish() {
1238 const auto end = fbb_.EndTable(start_);
1239 auto o = flatbuffers::Offset<Selu>(end);
1240 return o;
1241 }
1242 };
1243
1244 inline flatbuffers::Offset<Selu> CreateSelu(
1245 flatbuffers::FlatBufferBuilder &_fbb,
1246 float scale = 0.0f,
1247 float alpha = 0.0f) {
1248 SeluBuilder builder_(_fbb);
1249 builder_.add_alpha(alpha);
1250 builder_.add_scale(scale);
1251 return builder_.Finish();
1252 }
1253
1254 flatbuffers::Offset<Selu> CreateSelu(flatbuffers::FlatBufferBuilder &_fbb, const SeluT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1255
1256 struct AsStringT : public flatbuffers::NativeTable {
1257 typedef AsString TableType;
1258 DataType T;
1259 int32_t precision;
1260 bool scientific;
1261 bool shortest;
1262 int32_t width;
1263 std::string fillString;
AsStringTAsStringT1264 AsStringT()
1265 : T(DataType_DT_INVALID),
1266 precision(0),
1267 scientific(false),
1268 shortest(false),
1269 width(0) {
1270 }
1271 };
1272
1273 struct AsString FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1274 typedef AsStringT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1275 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1276 return AsStringTypeTable();
1277 }
TFLATBUFFERS_FINAL_CLASS1278 DataType T() const {
1279 return static_cast<DataType>(GetField<int32_t>(4, 0));
1280 }
precisionFLATBUFFERS_FINAL_CLASS1281 int32_t precision() const {
1282 return GetField<int32_t>(6, 0);
1283 }
scientificFLATBUFFERS_FINAL_CLASS1284 bool scientific() const {
1285 return GetField<uint8_t>(8, 0) != 0;
1286 }
shortestFLATBUFFERS_FINAL_CLASS1287 bool shortest() const {
1288 return GetField<uint8_t>(10, 0) != 0;
1289 }
widthFLATBUFFERS_FINAL_CLASS1290 int32_t width() const {
1291 return GetField<int32_t>(12, 0);
1292 }
fillStringFLATBUFFERS_FINAL_CLASS1293 const flatbuffers::String *fillString() const {
1294 return GetPointer<const flatbuffers::String *>(14);
1295 }
VerifyFLATBUFFERS_FINAL_CLASS1296 bool Verify(flatbuffers::Verifier &verifier) const {
1297 return VerifyTableStart(verifier) &&
1298 VerifyField<int32_t>(verifier, 4) &&
1299 VerifyField<int32_t>(verifier, 6) &&
1300 VerifyField<uint8_t>(verifier, 8) &&
1301 VerifyField<uint8_t>(verifier, 10) &&
1302 VerifyField<int32_t>(verifier, 12) &&
1303 VerifyOffset(verifier, 14) &&
1304 verifier.VerifyString(fillString()) &&
1305 verifier.EndTable();
1306 }
1307 AsStringT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1308 void UnPackTo(AsStringT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1309 static flatbuffers::Offset<AsString> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AsStringT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1310 };
1311
1312 struct AsStringBuilder {
1313 flatbuffers::FlatBufferBuilder &fbb_;
1314 flatbuffers::uoffset_t start_;
add_TAsStringBuilder1315 void add_T(DataType T) {
1316 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(T), 0);
1317 }
add_precisionAsStringBuilder1318 void add_precision(int32_t precision) {
1319 fbb_.AddElement<int32_t>(6, precision, 0);
1320 }
add_scientificAsStringBuilder1321 void add_scientific(bool scientific) {
1322 fbb_.AddElement<uint8_t>(8, static_cast<uint8_t>(scientific), 0);
1323 }
add_shortestAsStringBuilder1324 void add_shortest(bool shortest) {
1325 fbb_.AddElement<uint8_t>(10, static_cast<uint8_t>(shortest), 0);
1326 }
add_widthAsStringBuilder1327 void add_width(int32_t width) {
1328 fbb_.AddElement<int32_t>(12, width, 0);
1329 }
add_fillStringAsStringBuilder1330 void add_fillString(flatbuffers::Offset<flatbuffers::String> fillString) {
1331 fbb_.AddOffset(14, fillString);
1332 }
AsStringBuilderAsStringBuilder1333 explicit AsStringBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1334 : fbb_(_fbb) {
1335 start_ = fbb_.StartTable();
1336 }
1337 AsStringBuilder &operator=(const AsStringBuilder &);
FinishAsStringBuilder1338 flatbuffers::Offset<AsString> Finish() {
1339 const auto end = fbb_.EndTable(start_);
1340 auto o = flatbuffers::Offset<AsString>(end);
1341 return o;
1342 }
1343 };
1344
1345 inline flatbuffers::Offset<AsString> CreateAsString(
1346 flatbuffers::FlatBufferBuilder &_fbb,
1347 DataType T = DataType_DT_INVALID,
1348 int32_t precision = 0,
1349 bool scientific = false,
1350 bool shortest = false,
1351 int32_t width = 0,
1352 flatbuffers::Offset<flatbuffers::String> fillString = 0) {
1353 AsStringBuilder builder_(_fbb);
1354 builder_.add_fillString(fillString);
1355 builder_.add_width(width);
1356 builder_.add_precision(precision);
1357 builder_.add_T(T);
1358 builder_.add_shortest(shortest);
1359 builder_.add_scientific(scientific);
1360 return builder_.Finish();
1361 }
1362
1363 flatbuffers::Offset<AsString> CreateAsString(flatbuffers::FlatBufferBuilder &_fbb, const AsStringT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1364
1365 struct ReduceJoinT : public flatbuffers::NativeTable {
1366 typedef ReduceJoin TableType;
1367 bool keepDims;
1368 std::string separator;
ReduceJoinTReduceJoinT1369 ReduceJoinT()
1370 : keepDims(false) {
1371 }
1372 };
1373
1374 struct ReduceJoin FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1375 typedef ReduceJoinT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1376 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1377 return ReduceJoinTypeTable();
1378 }
keepDimsFLATBUFFERS_FINAL_CLASS1379 bool keepDims() const {
1380 return GetField<uint8_t>(4, 0) != 0;
1381 }
separatorFLATBUFFERS_FINAL_CLASS1382 const flatbuffers::String *separator() const {
1383 return GetPointer<const flatbuffers::String *>(6);
1384 }
VerifyFLATBUFFERS_FINAL_CLASS1385 bool Verify(flatbuffers::Verifier &verifier) const {
1386 return VerifyTableStart(verifier) &&
1387 VerifyField<uint8_t>(verifier, 4) &&
1388 VerifyOffset(verifier, 6) &&
1389 verifier.VerifyString(separator()) &&
1390 verifier.EndTable();
1391 }
1392 ReduceJoinT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1393 void UnPackTo(ReduceJoinT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1394 static flatbuffers::Offset<ReduceJoin> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReduceJoinT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1395 };
1396
1397 struct ReduceJoinBuilder {
1398 flatbuffers::FlatBufferBuilder &fbb_;
1399 flatbuffers::uoffset_t start_;
add_keepDimsReduceJoinBuilder1400 void add_keepDims(bool keepDims) {
1401 fbb_.AddElement<uint8_t>(4, static_cast<uint8_t>(keepDims), 0);
1402 }
add_separatorReduceJoinBuilder1403 void add_separator(flatbuffers::Offset<flatbuffers::String> separator) {
1404 fbb_.AddOffset(6, separator);
1405 }
ReduceJoinBuilderReduceJoinBuilder1406 explicit ReduceJoinBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1407 : fbb_(_fbb) {
1408 start_ = fbb_.StartTable();
1409 }
1410 ReduceJoinBuilder &operator=(const ReduceJoinBuilder &);
FinishReduceJoinBuilder1411 flatbuffers::Offset<ReduceJoin> Finish() {
1412 const auto end = fbb_.EndTable(start_);
1413 auto o = flatbuffers::Offset<ReduceJoin>(end);
1414 return o;
1415 }
1416 };
1417
1418 inline flatbuffers::Offset<ReduceJoin> CreateReduceJoin(
1419 flatbuffers::FlatBufferBuilder &_fbb,
1420 bool keepDims = false,
1421 flatbuffers::Offset<flatbuffers::String> separator = 0) {
1422 ReduceJoinBuilder builder_(_fbb);
1423 builder_.add_separator(separator);
1424 builder_.add_keepDims(keepDims);
1425 return builder_.Finish();
1426 }
1427
1428 flatbuffers::Offset<ReduceJoin> CreateReduceJoin(flatbuffers::FlatBufferBuilder &_fbb, const ReduceJoinT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1429
1430 struct UnaryOpT : public flatbuffers::NativeTable {
1431 typedef UnaryOp TableType;
1432 UnaryOpOperation opType;
1433 DataType T;
UnaryOpTUnaryOpT1434 UnaryOpT()
1435 : opType(UnaryOpOperation_ABS),
1436 T(DataType_DT_INVALID) {
1437 }
1438 };
1439
1440 struct UnaryOp FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1441 typedef UnaryOpT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1442 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1443 return UnaryOpTypeTable();
1444 }
opTypeFLATBUFFERS_FINAL_CLASS1445 UnaryOpOperation opType() const {
1446 return static_cast<UnaryOpOperation>(GetField<int32_t>(4, 0));
1447 }
TFLATBUFFERS_FINAL_CLASS1448 DataType T() const {
1449 return static_cast<DataType>(GetField<int32_t>(6, 0));
1450 }
VerifyFLATBUFFERS_FINAL_CLASS1451 bool Verify(flatbuffers::Verifier &verifier) const {
1452 return VerifyTableStart(verifier) &&
1453 VerifyField<int32_t>(verifier, 4) &&
1454 VerifyField<int32_t>(verifier, 6) &&
1455 verifier.EndTable();
1456 }
1457 UnaryOpT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1458 void UnPackTo(UnaryOpT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1459 static flatbuffers::Offset<UnaryOp> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnaryOpT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1460 };
1461
1462 struct UnaryOpBuilder {
1463 flatbuffers::FlatBufferBuilder &fbb_;
1464 flatbuffers::uoffset_t start_;
add_opTypeUnaryOpBuilder1465 void add_opType(UnaryOpOperation opType) {
1466 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(opType), 0);
1467 }
add_TUnaryOpBuilder1468 void add_T(DataType T) {
1469 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(T), 0);
1470 }
UnaryOpBuilderUnaryOpBuilder1471 explicit UnaryOpBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1472 : fbb_(_fbb) {
1473 start_ = fbb_.StartTable();
1474 }
1475 UnaryOpBuilder &operator=(const UnaryOpBuilder &);
FinishUnaryOpBuilder1476 flatbuffers::Offset<UnaryOp> Finish() {
1477 const auto end = fbb_.EndTable(start_);
1478 auto o = flatbuffers::Offset<UnaryOp>(end);
1479 return o;
1480 }
1481 };
1482
1483 inline flatbuffers::Offset<UnaryOp> CreateUnaryOp(
1484 flatbuffers::FlatBufferBuilder &_fbb,
1485 UnaryOpOperation opType = UnaryOpOperation_ABS,
1486 DataType T = DataType_DT_INVALID) {
1487 UnaryOpBuilder builder_(_fbb);
1488 builder_.add_T(T);
1489 builder_.add_opType(opType);
1490 return builder_.Finish();
1491 }
1492
1493 flatbuffers::Offset<UnaryOp> CreateUnaryOp(flatbuffers::FlatBufferBuilder &_fbb, const UnaryOpT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1494
1495 struct TopKV2T : public flatbuffers::NativeTable {
1496 typedef TopKV2 TableType;
1497 DataType T;
1498 bool sorted;
TopKV2TTopKV2T1499 TopKV2T()
1500 : T(DataType_DT_FLOAT),
1501 sorted(false) {
1502 }
1503 };
1504
1505 struct TopKV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1506 typedef TopKV2T NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1507 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1508 return TopKV2TypeTable();
1509 }
TFLATBUFFERS_FINAL_CLASS1510 DataType T() const {
1511 return static_cast<DataType>(GetField<int32_t>(4, 1));
1512 }
sortedFLATBUFFERS_FINAL_CLASS1513 bool sorted() const {
1514 return GetField<uint8_t>(6, 0) != 0;
1515 }
VerifyFLATBUFFERS_FINAL_CLASS1516 bool Verify(flatbuffers::Verifier &verifier) const {
1517 return VerifyTableStart(verifier) &&
1518 VerifyField<int32_t>(verifier, 4) &&
1519 VerifyField<uint8_t>(verifier, 6) &&
1520 verifier.EndTable();
1521 }
1522 TopKV2T *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1523 void UnPackTo(TopKV2T *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1524 static flatbuffers::Offset<TopKV2> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2T* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1525 };
1526
1527 struct TopKV2Builder {
1528 flatbuffers::FlatBufferBuilder &fbb_;
1529 flatbuffers::uoffset_t start_;
add_TTopKV2Builder1530 void add_T(DataType T) {
1531 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(T), 1);
1532 }
add_sortedTopKV2Builder1533 void add_sorted(bool sorted) {
1534 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(sorted), 0);
1535 }
TopKV2BuilderTopKV2Builder1536 explicit TopKV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
1537 : fbb_(_fbb) {
1538 start_ = fbb_.StartTable();
1539 }
1540 TopKV2Builder &operator=(const TopKV2Builder &);
FinishTopKV2Builder1541 flatbuffers::Offset<TopKV2> Finish() {
1542 const auto end = fbb_.EndTable(start_);
1543 auto o = flatbuffers::Offset<TopKV2>(end);
1544 return o;
1545 }
1546 };
1547
1548 inline flatbuffers::Offset<TopKV2> CreateTopKV2(
1549 flatbuffers::FlatBufferBuilder &_fbb,
1550 DataType T = DataType_DT_FLOAT,
1551 bool sorted = false) {
1552 TopKV2Builder builder_(_fbb);
1553 builder_.add_T(T);
1554 builder_.add_sorted(sorted);
1555 return builder_.Finish();
1556 }
1557
1558 flatbuffers::Offset<TopKV2> CreateTopKV2(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2T *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1559
1560 struct CropAndResizeT : public flatbuffers::NativeTable {
1561 typedef CropAndResize TableType;
1562 float extrapolationValue;
1563 CropAndResizeMethod method;
CropAndResizeTCropAndResizeT1564 CropAndResizeT()
1565 : extrapolationValue(0.0f),
1566 method(CropAndResizeMethod_BILINEAR) {
1567 }
1568 };
1569
1570 struct CropAndResize FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1571 typedef CropAndResizeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1572 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1573 return CropAndResizeTypeTable();
1574 }
extrapolationValueFLATBUFFERS_FINAL_CLASS1575 float extrapolationValue() const {
1576 return GetField<float>(4, 0.0f);
1577 }
methodFLATBUFFERS_FINAL_CLASS1578 CropAndResizeMethod method() const {
1579 return static_cast<CropAndResizeMethod>(GetField<int8_t>(6, 0));
1580 }
VerifyFLATBUFFERS_FINAL_CLASS1581 bool Verify(flatbuffers::Verifier &verifier) const {
1582 return VerifyTableStart(verifier) &&
1583 VerifyField<float>(verifier, 4) &&
1584 VerifyField<int8_t>(verifier, 6) &&
1585 verifier.EndTable();
1586 }
1587 CropAndResizeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1588 void UnPackTo(CropAndResizeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1589 static flatbuffers::Offset<CropAndResize> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CropAndResizeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1590 };
1591
1592 struct CropAndResizeBuilder {
1593 flatbuffers::FlatBufferBuilder &fbb_;
1594 flatbuffers::uoffset_t start_;
add_extrapolationValueCropAndResizeBuilder1595 void add_extrapolationValue(float extrapolationValue) {
1596 fbb_.AddElement<float>(4, extrapolationValue, 0.0f);
1597 }
add_methodCropAndResizeBuilder1598 void add_method(CropAndResizeMethod method) {
1599 fbb_.AddElement<int8_t>(6, static_cast<int8_t>(method), 0);
1600 }
CropAndResizeBuilderCropAndResizeBuilder1601 explicit CropAndResizeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1602 : fbb_(_fbb) {
1603 start_ = fbb_.StartTable();
1604 }
1605 CropAndResizeBuilder &operator=(const CropAndResizeBuilder &);
FinishCropAndResizeBuilder1606 flatbuffers::Offset<CropAndResize> Finish() {
1607 const auto end = fbb_.EndTable(start_);
1608 auto o = flatbuffers::Offset<CropAndResize>(end);
1609 return o;
1610 }
1611 };
1612
1613 inline flatbuffers::Offset<CropAndResize> CreateCropAndResize(
1614 flatbuffers::FlatBufferBuilder &_fbb,
1615 float extrapolationValue = 0.0f,
1616 CropAndResizeMethod method = CropAndResizeMethod_BILINEAR) {
1617 CropAndResizeBuilder builder_(_fbb);
1618 builder_.add_extrapolationValue(extrapolationValue);
1619 builder_.add_method(method);
1620 return builder_.Finish();
1621 }
1622
1623 flatbuffers::Offset<CropAndResize> CreateCropAndResize(flatbuffers::FlatBufferBuilder &_fbb, const CropAndResizeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1624
1625 struct FillT : public flatbuffers::NativeTable {
1626 typedef Fill TableType;
FillTFillT1627 FillT() {
1628 }
1629 };
1630
1631 struct Fill FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1632 typedef FillT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1633 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1634 return FillTypeTable();
1635 }
VerifyFLATBUFFERS_FINAL_CLASS1636 bool Verify(flatbuffers::Verifier &verifier) const {
1637 return VerifyTableStart(verifier) &&
1638 verifier.EndTable();
1639 }
1640 FillT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1641 void UnPackTo(FillT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1642 static flatbuffers::Offset<Fill> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1643 };
1644
1645 struct FillBuilder {
1646 flatbuffers::FlatBufferBuilder &fbb_;
1647 flatbuffers::uoffset_t start_;
FillBuilderFillBuilder1648 explicit FillBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1649 : fbb_(_fbb) {
1650 start_ = fbb_.StartTable();
1651 }
1652 FillBuilder &operator=(const FillBuilder &);
FinishFillBuilder1653 flatbuffers::Offset<Fill> Finish() {
1654 const auto end = fbb_.EndTable(start_);
1655 auto o = flatbuffers::Offset<Fill>(end);
1656 return o;
1657 }
1658 };
1659
CreateFill(flatbuffers::FlatBufferBuilder & _fbb)1660 inline flatbuffers::Offset<Fill> CreateFill(
1661 flatbuffers::FlatBufferBuilder &_fbb) {
1662 FillBuilder builder_(_fbb);
1663 return builder_.Finish();
1664 }
1665
1666 flatbuffers::Offset<Fill> CreateFill(flatbuffers::FlatBufferBuilder &_fbb, const FillT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1667
1668 struct GatherV2T : public flatbuffers::NativeTable {
1669 typedef GatherV2 TableType;
1670 DataType Taxis;
1671 DataType Tindices;
1672 DataType Tparams;
GatherV2TGatherV2T1673 GatherV2T()
1674 : Taxis(DataType_DT_INVALID),
1675 Tindices(DataType_DT_INVALID),
1676 Tparams(DataType_DT_INVALID) {
1677 }
1678 };
1679
1680 struct GatherV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1681 typedef GatherV2T NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1682 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1683 return GatherV2TypeTable();
1684 }
TaxisFLATBUFFERS_FINAL_CLASS1685 DataType Taxis() const {
1686 return static_cast<DataType>(GetField<int32_t>(4, 0));
1687 }
TindicesFLATBUFFERS_FINAL_CLASS1688 DataType Tindices() const {
1689 return static_cast<DataType>(GetField<int32_t>(6, 0));
1690 }
TparamsFLATBUFFERS_FINAL_CLASS1691 DataType Tparams() const {
1692 return static_cast<DataType>(GetField<int32_t>(8, 0));
1693 }
VerifyFLATBUFFERS_FINAL_CLASS1694 bool Verify(flatbuffers::Verifier &verifier) const {
1695 return VerifyTableStart(verifier) &&
1696 VerifyField<int32_t>(verifier, 4) &&
1697 VerifyField<int32_t>(verifier, 6) &&
1698 VerifyField<int32_t>(verifier, 8) &&
1699 verifier.EndTable();
1700 }
1701 GatherV2T *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1702 void UnPackTo(GatherV2T *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1703 static flatbuffers::Offset<GatherV2> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherV2T* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1704 };
1705
1706 struct GatherV2Builder {
1707 flatbuffers::FlatBufferBuilder &fbb_;
1708 flatbuffers::uoffset_t start_;
add_TaxisGatherV2Builder1709 void add_Taxis(DataType Taxis) {
1710 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(Taxis), 0);
1711 }
add_TindicesGatherV2Builder1712 void add_Tindices(DataType Tindices) {
1713 fbb_.AddElement<int32_t>(6, static_cast<int32_t>(Tindices), 0);
1714 }
add_TparamsGatherV2Builder1715 void add_Tparams(DataType Tparams) {
1716 fbb_.AddElement<int32_t>(8, static_cast<int32_t>(Tparams), 0);
1717 }
GatherV2BuilderGatherV2Builder1718 explicit GatherV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
1719 : fbb_(_fbb) {
1720 start_ = fbb_.StartTable();
1721 }
1722 GatherV2Builder &operator=(const GatherV2Builder &);
FinishGatherV2Builder1723 flatbuffers::Offset<GatherV2> Finish() {
1724 const auto end = fbb_.EndTable(start_);
1725 auto o = flatbuffers::Offset<GatherV2>(end);
1726 return o;
1727 }
1728 };
1729
1730 inline flatbuffers::Offset<GatherV2> CreateGatherV2(
1731 flatbuffers::FlatBufferBuilder &_fbb,
1732 DataType Taxis = DataType_DT_INVALID,
1733 DataType Tindices = DataType_DT_INVALID,
1734 DataType Tparams = DataType_DT_INVALID) {
1735 GatherV2Builder builder_(_fbb);
1736 builder_.add_Tparams(Tparams);
1737 builder_.add_Tindices(Tindices);
1738 builder_.add_Taxis(Taxis);
1739 return builder_.Finish();
1740 }
1741
1742 flatbuffers::Offset<GatherV2> CreateGatherV2(flatbuffers::FlatBufferBuilder &_fbb, const GatherV2T *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1743
1744 struct NonMaxSuppressionV2T : public flatbuffers::NativeTable {
1745 typedef NonMaxSuppressionV2 TableType;
NonMaxSuppressionV2TNonMaxSuppressionV2T1746 NonMaxSuppressionV2T() {
1747 }
1748 };
1749
1750 struct NonMaxSuppressionV2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1751 typedef NonMaxSuppressionV2T NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1752 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1753 return NonMaxSuppressionV2TypeTable();
1754 }
VerifyFLATBUFFERS_FINAL_CLASS1755 bool Verify(flatbuffers::Verifier &verifier) const {
1756 return VerifyTableStart(verifier) &&
1757 verifier.EndTable();
1758 }
1759 NonMaxSuppressionV2T *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1760 void UnPackTo(NonMaxSuppressionV2T *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1761 static flatbuffers::Offset<NonMaxSuppressionV2> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV2T* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1762 };
1763
1764 struct NonMaxSuppressionV2Builder {
1765 flatbuffers::FlatBufferBuilder &fbb_;
1766 flatbuffers::uoffset_t start_;
NonMaxSuppressionV2BuilderNonMaxSuppressionV2Builder1767 explicit NonMaxSuppressionV2Builder(flatbuffers::FlatBufferBuilder &_fbb)
1768 : fbb_(_fbb) {
1769 start_ = fbb_.StartTable();
1770 }
1771 NonMaxSuppressionV2Builder &operator=(const NonMaxSuppressionV2Builder &);
FinishNonMaxSuppressionV2Builder1772 flatbuffers::Offset<NonMaxSuppressionV2> Finish() {
1773 const auto end = fbb_.EndTable(start_);
1774 auto o = flatbuffers::Offset<NonMaxSuppressionV2>(end);
1775 return o;
1776 }
1777 };
1778
CreateNonMaxSuppressionV2(flatbuffers::FlatBufferBuilder & _fbb)1779 inline flatbuffers::Offset<NonMaxSuppressionV2> CreateNonMaxSuppressionV2(
1780 flatbuffers::FlatBufferBuilder &_fbb) {
1781 NonMaxSuppressionV2Builder builder_(_fbb);
1782 return builder_.Finish();
1783 }
1784
1785 flatbuffers::Offset<NonMaxSuppressionV2> CreateNonMaxSuppressionV2(flatbuffers::FlatBufferBuilder &_fbb, const NonMaxSuppressionV2T *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1786
1787 struct RangeT : public flatbuffers::NativeTable {
1788 typedef Range TableType;
1789 DataType Tidx;
RangeTRangeT1790 RangeT()
1791 : Tidx(DataType_DT_INVALID) {
1792 }
1793 };
1794
1795 struct Range FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1796 typedef RangeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1797 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1798 return RangeTypeTable();
1799 }
TidxFLATBUFFERS_FINAL_CLASS1800 DataType Tidx() const {
1801 return static_cast<DataType>(GetField<int32_t>(4, 0));
1802 }
VerifyFLATBUFFERS_FINAL_CLASS1803 bool Verify(flatbuffers::Verifier &verifier) const {
1804 return VerifyTableStart(verifier) &&
1805 VerifyField<int32_t>(verifier, 4) &&
1806 verifier.EndTable();
1807 }
1808 RangeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1809 void UnPackTo(RangeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1810 static flatbuffers::Offset<Range> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1811 };
1812
1813 struct RangeBuilder {
1814 flatbuffers::FlatBufferBuilder &fbb_;
1815 flatbuffers::uoffset_t start_;
add_TidxRangeBuilder1816 void add_Tidx(DataType Tidx) {
1817 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(Tidx), 0);
1818 }
RangeBuilderRangeBuilder1819 explicit RangeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1820 : fbb_(_fbb) {
1821 start_ = fbb_.StartTable();
1822 }
1823 RangeBuilder &operator=(const RangeBuilder &);
FinishRangeBuilder1824 flatbuffers::Offset<Range> Finish() {
1825 const auto end = fbb_.EndTable(start_);
1826 auto o = flatbuffers::Offset<Range>(end);
1827 return o;
1828 }
1829 };
1830
1831 inline flatbuffers::Offset<Range> CreateRange(
1832 flatbuffers::FlatBufferBuilder &_fbb,
1833 DataType Tidx = DataType_DT_INVALID) {
1834 RangeBuilder builder_(_fbb);
1835 builder_.add_Tidx(Tidx);
1836 return builder_.Finish();
1837 }
1838
1839 flatbuffers::Offset<Range> CreateRange(flatbuffers::FlatBufferBuilder &_fbb, const RangeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1840
1841 struct RankT : public flatbuffers::NativeTable {
1842 typedef Rank TableType;
RankTRankT1843 RankT() {
1844 }
1845 };
1846
1847 struct Rank FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1848 typedef RankT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1849 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1850 return RankTypeTable();
1851 }
VerifyFLATBUFFERS_FINAL_CLASS1852 bool Verify(flatbuffers::Verifier &verifier) const {
1853 return VerifyTableStart(verifier) &&
1854 verifier.EndTable();
1855 }
1856 RankT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1857 void UnPackTo(RankT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1858 static flatbuffers::Offset<Rank> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1859 };
1860
1861 struct RankBuilder {
1862 flatbuffers::FlatBufferBuilder &fbb_;
1863 flatbuffers::uoffset_t start_;
RankBuilderRankBuilder1864 explicit RankBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1865 : fbb_(_fbb) {
1866 start_ = fbb_.StartTable();
1867 }
1868 RankBuilder &operator=(const RankBuilder &);
FinishRankBuilder1869 flatbuffers::Offset<Rank> Finish() {
1870 const auto end = fbb_.EndTable(start_);
1871 auto o = flatbuffers::Offset<Rank>(end);
1872 return o;
1873 }
1874 };
1875
CreateRank(flatbuffers::FlatBufferBuilder & _fbb)1876 inline flatbuffers::Offset<Rank> CreateRank(
1877 flatbuffers::FlatBufferBuilder &_fbb) {
1878 RankBuilder builder_(_fbb);
1879 return builder_.Finish();
1880 }
1881
1882 flatbuffers::Offset<Rank> CreateRank(flatbuffers::FlatBufferBuilder &_fbb, const RankT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1883
1884 struct SizeT : public flatbuffers::NativeTable {
1885 typedef Size TableType;
1886 DataType outputDataType;
SizeTSizeT1887 SizeT()
1888 : outputDataType(DataType_DT_INVALID) {
1889 }
1890 };
1891
1892 struct Size FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1893 typedef SizeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1894 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1895 return SizeTypeTable();
1896 }
outputDataTypeFLATBUFFERS_FINAL_CLASS1897 DataType outputDataType() const {
1898 return static_cast<DataType>(GetField<int32_t>(4, 0));
1899 }
VerifyFLATBUFFERS_FINAL_CLASS1900 bool Verify(flatbuffers::Verifier &verifier) const {
1901 return VerifyTableStart(verifier) &&
1902 VerifyField<int32_t>(verifier, 4) &&
1903 verifier.EndTable();
1904 }
1905 SizeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1906 void UnPackTo(SizeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1907 static flatbuffers::Offset<Size> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SizeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1908 };
1909
1910 struct SizeBuilder {
1911 flatbuffers::FlatBufferBuilder &fbb_;
1912 flatbuffers::uoffset_t start_;
add_outputDataTypeSizeBuilder1913 void add_outputDataType(DataType outputDataType) {
1914 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(outputDataType), 0);
1915 }
SizeBuilderSizeBuilder1916 explicit SizeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1917 : fbb_(_fbb) {
1918 start_ = fbb_.StartTable();
1919 }
1920 SizeBuilder &operator=(const SizeBuilder &);
FinishSizeBuilder1921 flatbuffers::Offset<Size> Finish() {
1922 const auto end = fbb_.EndTable(start_);
1923 auto o = flatbuffers::Offset<Size>(end);
1924 return o;
1925 }
1926 };
1927
1928 inline flatbuffers::Offset<Size> CreateSize(
1929 flatbuffers::FlatBufferBuilder &_fbb,
1930 DataType outputDataType = DataType_DT_INVALID) {
1931 SizeBuilder builder_(_fbb);
1932 builder_.add_outputDataType(outputDataType);
1933 return builder_.Finish();
1934 }
1935
1936 flatbuffers::Offset<Size> CreateSize(flatbuffers::FlatBufferBuilder &_fbb, const SizeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1937
1938 struct TransposeT : public flatbuffers::NativeTable {
1939 typedef Transpose TableType;
1940 DataType Tperm;
TransposeTTransposeT1941 TransposeT()
1942 : Tperm(DataType_DT_INVALID) {
1943 }
1944 };
1945
1946 struct Transpose FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1947 typedef TransposeT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS1948 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
1949 return TransposeTypeTable();
1950 }
TpermFLATBUFFERS_FINAL_CLASS1951 DataType Tperm() const {
1952 return static_cast<DataType>(GetField<int32_t>(4, 0));
1953 }
VerifyFLATBUFFERS_FINAL_CLASS1954 bool Verify(flatbuffers::Verifier &verifier) const {
1955 return VerifyTableStart(verifier) &&
1956 VerifyField<int32_t>(verifier, 4) &&
1957 verifier.EndTable();
1958 }
1959 TransposeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1960 void UnPackTo(TransposeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1961 static flatbuffers::Offset<Transpose> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1962 };
1963
1964 struct TransposeBuilder {
1965 flatbuffers::FlatBufferBuilder &fbb_;
1966 flatbuffers::uoffset_t start_;
add_TpermTransposeBuilder1967 void add_Tperm(DataType Tperm) {
1968 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(Tperm), 0);
1969 }
TransposeBuilderTransposeBuilder1970 explicit TransposeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1971 : fbb_(_fbb) {
1972 start_ = fbb_.StartTable();
1973 }
1974 TransposeBuilder &operator=(const TransposeBuilder &);
FinishTransposeBuilder1975 flatbuffers::Offset<Transpose> Finish() {
1976 const auto end = fbb_.EndTable(start_);
1977 auto o = flatbuffers::Offset<Transpose>(end);
1978 return o;
1979 }
1980 };
1981
1982 inline flatbuffers::Offset<Transpose> CreateTranspose(
1983 flatbuffers::FlatBufferBuilder &_fbb,
1984 DataType Tperm = DataType_DT_INVALID) {
1985 TransposeBuilder builder_(_fbb);
1986 builder_.add_Tperm(Tperm);
1987 return builder_.Finish();
1988 }
1989
1990 flatbuffers::Offset<Transpose> CreateTranspose(flatbuffers::FlatBufferBuilder &_fbb, const TransposeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1991
1992 struct SliceTfT : public flatbuffers::NativeTable {
1993 typedef SliceTf TableType;
1994 DataType T;
SliceTfTSliceTfT1995 SliceTfT()
1996 : T(DataType_DT_INVALID) {
1997 }
1998 };
1999
2000 struct SliceTf FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2001 typedef SliceTfT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2002 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2003 return SliceTfTypeTable();
2004 }
TFLATBUFFERS_FINAL_CLASS2005 DataType T() const {
2006 return static_cast<DataType>(GetField<int32_t>(4, 0));
2007 }
VerifyFLATBUFFERS_FINAL_CLASS2008 bool Verify(flatbuffers::Verifier &verifier) const {
2009 return VerifyTableStart(verifier) &&
2010 VerifyField<int32_t>(verifier, 4) &&
2011 verifier.EndTable();
2012 }
2013 SliceTfT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2014 void UnPackTo(SliceTfT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2015 static flatbuffers::Offset<SliceTf> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceTfT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2016 };
2017
2018 struct SliceTfBuilder {
2019 flatbuffers::FlatBufferBuilder &fbb_;
2020 flatbuffers::uoffset_t start_;
add_TSliceTfBuilder2021 void add_T(DataType T) {
2022 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(T), 0);
2023 }
SliceTfBuilderSliceTfBuilder2024 explicit SliceTfBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2025 : fbb_(_fbb) {
2026 start_ = fbb_.StartTable();
2027 }
2028 SliceTfBuilder &operator=(const SliceTfBuilder &);
FinishSliceTfBuilder2029 flatbuffers::Offset<SliceTf> Finish() {
2030 const auto end = fbb_.EndTable(start_);
2031 auto o = flatbuffers::Offset<SliceTf>(end);
2032 return o;
2033 }
2034 };
2035
2036 inline flatbuffers::Offset<SliceTf> CreateSliceTf(
2037 flatbuffers::FlatBufferBuilder &_fbb,
2038 DataType T = DataType_DT_INVALID) {
2039 SliceTfBuilder builder_(_fbb);
2040 builder_.add_T(T);
2041 return builder_.Finish();
2042 }
2043
2044 flatbuffers::Offset<SliceTf> CreateSliceTf(flatbuffers::FlatBufferBuilder &_fbb, const SliceTfT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2045
2046 struct QuantizeMaxMinT : public flatbuffers::NativeTable {
2047 typedef QuantizeMaxMin TableType;
2048 DataType T;
QuantizeMaxMinTQuantizeMaxMinT2049 QuantizeMaxMinT()
2050 : T(DataType_DT_INVALID) {
2051 }
2052 };
2053
2054 struct QuantizeMaxMin FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2055 typedef QuantizeMaxMinT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2056 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2057 return QuantizeMaxMinTypeTable();
2058 }
TFLATBUFFERS_FINAL_CLASS2059 DataType T() const {
2060 return static_cast<DataType>(GetField<int32_t>(4, 0));
2061 }
VerifyFLATBUFFERS_FINAL_CLASS2062 bool Verify(flatbuffers::Verifier &verifier) const {
2063 return VerifyTableStart(verifier) &&
2064 VerifyField<int32_t>(verifier, 4) &&
2065 verifier.EndTable();
2066 }
2067 QuantizeMaxMinT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2068 void UnPackTo(QuantizeMaxMinT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2069 static flatbuffers::Offset<QuantizeMaxMin> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeMaxMinT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2070 };
2071
2072 struct QuantizeMaxMinBuilder {
2073 flatbuffers::FlatBufferBuilder &fbb_;
2074 flatbuffers::uoffset_t start_;
add_TQuantizeMaxMinBuilder2075 void add_T(DataType T) {
2076 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(T), 0);
2077 }
QuantizeMaxMinBuilderQuantizeMaxMinBuilder2078 explicit QuantizeMaxMinBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2079 : fbb_(_fbb) {
2080 start_ = fbb_.StartTable();
2081 }
2082 QuantizeMaxMinBuilder &operator=(const QuantizeMaxMinBuilder &);
FinishQuantizeMaxMinBuilder2083 flatbuffers::Offset<QuantizeMaxMin> Finish() {
2084 const auto end = fbb_.EndTable(start_);
2085 auto o = flatbuffers::Offset<QuantizeMaxMin>(end);
2086 return o;
2087 }
2088 };
2089
2090 inline flatbuffers::Offset<QuantizeMaxMin> CreateQuantizeMaxMin(
2091 flatbuffers::FlatBufferBuilder &_fbb,
2092 DataType T = DataType_DT_INVALID) {
2093 QuantizeMaxMinBuilder builder_(_fbb);
2094 builder_.add_T(T);
2095 return builder_.Finish();
2096 }
2097
2098 flatbuffers::Offset<QuantizeMaxMin> CreateQuantizeMaxMin(flatbuffers::FlatBufferBuilder &_fbb, const QuantizeMaxMinT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2099
2100 struct CropT : public flatbuffers::NativeTable {
2101 typedef Crop TableType;
2102 int32_t axis;
2103 std::vector<int32_t> offset;
CropTCropT2104 CropT()
2105 : axis(2) {
2106 }
2107 };
2108
2109 struct Crop FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2110 typedef CropT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2111 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2112 return CropTypeTable();
2113 }
axisFLATBUFFERS_FINAL_CLASS2114 int32_t axis() const {
2115 return GetField<int32_t>(4, 2);
2116 }
offsetFLATBUFFERS_FINAL_CLASS2117 const flatbuffers::Vector<int32_t> *offset() const {
2118 return GetPointer<const flatbuffers::Vector<int32_t> *>(6);
2119 }
VerifyFLATBUFFERS_FINAL_CLASS2120 bool Verify(flatbuffers::Verifier &verifier) const {
2121 return VerifyTableStart(verifier) &&
2122 VerifyField<int32_t>(verifier, 4) &&
2123 VerifyOffset(verifier, 6) &&
2124 verifier.VerifyVector(offset()) &&
2125 verifier.EndTable();
2126 }
2127 CropT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2128 void UnPackTo(CropT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2129 static flatbuffers::Offset<Crop> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CropT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2130 };
2131
2132 struct CropBuilder {
2133 flatbuffers::FlatBufferBuilder &fbb_;
2134 flatbuffers::uoffset_t start_;
add_axisCropBuilder2135 void add_axis(int32_t axis) {
2136 fbb_.AddElement<int32_t>(4, axis, 2);
2137 }
add_offsetCropBuilder2138 void add_offset(flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset) {
2139 fbb_.AddOffset(6, offset);
2140 }
CropBuilderCropBuilder2141 explicit CropBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2142 : fbb_(_fbb) {
2143 start_ = fbb_.StartTable();
2144 }
2145 CropBuilder &operator=(const CropBuilder &);
FinishCropBuilder2146 flatbuffers::Offset<Crop> Finish() {
2147 const auto end = fbb_.EndTable(start_);
2148 auto o = flatbuffers::Offset<Crop>(end);
2149 return o;
2150 }
2151 };
2152
2153 inline flatbuffers::Offset<Crop> CreateCrop(
2154 flatbuffers::FlatBufferBuilder &_fbb,
2155 int32_t axis = 2,
2156 flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset = 0) {
2157 CropBuilder builder_(_fbb);
2158 builder_.add_offset(offset);
2159 builder_.add_axis(axis);
2160 return builder_.Finish();
2161 }
2162
2163 flatbuffers::Offset<Crop> CreateCrop(flatbuffers::FlatBufferBuilder &_fbb, const CropT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2164
2165 struct SpaceBatchT : public flatbuffers::NativeTable {
2166 typedef SpaceBatch TableType;
2167 std::unique_ptr<BlobT> blockShape;
2168 std::unique_ptr<BlobT> padding;
SpaceBatchTSpaceBatchT2169 SpaceBatchT() {
2170 }
2171 };
2172
2173 struct SpaceBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2174 typedef SpaceBatchT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2175 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2176 return SpaceBatchTypeTable();
2177 }
blockShapeFLATBUFFERS_FINAL_CLASS2178 const Blob *blockShape() const {
2179 return GetPointer<const Blob *>(4);
2180 }
paddingFLATBUFFERS_FINAL_CLASS2181 const Blob *padding() const {
2182 return GetPointer<const Blob *>(6);
2183 }
VerifyFLATBUFFERS_FINAL_CLASS2184 bool Verify(flatbuffers::Verifier &verifier) const {
2185 return VerifyTableStart(verifier) &&
2186 VerifyOffset(verifier, 4) &&
2187 verifier.VerifyTable(blockShape()) &&
2188 VerifyOffset(verifier, 6) &&
2189 verifier.VerifyTable(padding()) &&
2190 verifier.EndTable();
2191 }
2192 SpaceBatchT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2193 void UnPackTo(SpaceBatchT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2194 static flatbuffers::Offset<SpaceBatch> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceBatchT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2195 };
2196
2197 struct SpaceBatchBuilder {
2198 flatbuffers::FlatBufferBuilder &fbb_;
2199 flatbuffers::uoffset_t start_;
add_blockShapeSpaceBatchBuilder2200 void add_blockShape(flatbuffers::Offset<Blob> blockShape) {
2201 fbb_.AddOffset(4, blockShape);
2202 }
add_paddingSpaceBatchBuilder2203 void add_padding(flatbuffers::Offset<Blob> padding) {
2204 fbb_.AddOffset(6, padding);
2205 }
SpaceBatchBuilderSpaceBatchBuilder2206 explicit SpaceBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2207 : fbb_(_fbb) {
2208 start_ = fbb_.StartTable();
2209 }
2210 SpaceBatchBuilder &operator=(const SpaceBatchBuilder &);
FinishSpaceBatchBuilder2211 flatbuffers::Offset<SpaceBatch> Finish() {
2212 const auto end = fbb_.EndTable(start_);
2213 auto o = flatbuffers::Offset<SpaceBatch>(end);
2214 return o;
2215 }
2216 };
2217
2218 inline flatbuffers::Offset<SpaceBatch> CreateSpaceBatch(
2219 flatbuffers::FlatBufferBuilder &_fbb,
2220 flatbuffers::Offset<Blob> blockShape = 0,
2221 flatbuffers::Offset<Blob> padding = 0) {
2222 SpaceBatchBuilder builder_(_fbb);
2223 builder_.add_padding(padding);
2224 builder_.add_blockShape(blockShape);
2225 return builder_.Finish();
2226 }
2227
2228 flatbuffers::Offset<SpaceBatch> CreateSpaceBatch(flatbuffers::FlatBufferBuilder &_fbb, const SpaceBatchT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2229
2230 struct MatMulT : public flatbuffers::NativeTable {
2231 typedef MatMul TableType;
2232 DataType T;
2233 bool transposeA;
2234 bool transposeB;
2235 std::vector<float> weight;
2236 std::vector<float> bias;
MatMulTMatMulT2237 MatMulT()
2238 : T(DataType_DT_INVALID),
2239 transposeA(false),
2240 transposeB(false) {
2241 }
2242 };
2243
2244 struct MatMul FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2245 typedef MatMulT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2246 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2247 return MatMulTypeTable();
2248 }
TFLATBUFFERS_FINAL_CLASS2249 DataType T() const {
2250 return static_cast<DataType>(GetField<int32_t>(4, 0));
2251 }
transposeAFLATBUFFERS_FINAL_CLASS2252 bool transposeA() const {
2253 return GetField<uint8_t>(6, 0) != 0;
2254 }
transposeBFLATBUFFERS_FINAL_CLASS2255 bool transposeB() const {
2256 return GetField<uint8_t>(8, 0) != 0;
2257 }
weightFLATBUFFERS_FINAL_CLASS2258 const flatbuffers::Vector<float> *weight() const {
2259 return GetPointer<const flatbuffers::Vector<float> *>(10);
2260 }
biasFLATBUFFERS_FINAL_CLASS2261 const flatbuffers::Vector<float> *bias() const {
2262 return GetPointer<const flatbuffers::Vector<float> *>(12);
2263 }
VerifyFLATBUFFERS_FINAL_CLASS2264 bool Verify(flatbuffers::Verifier &verifier) const {
2265 return VerifyTableStart(verifier) &&
2266 VerifyField<int32_t>(verifier, 4) &&
2267 VerifyField<uint8_t>(verifier, 6) &&
2268 VerifyField<uint8_t>(verifier, 8) &&
2269 VerifyOffset(verifier, 10) &&
2270 verifier.VerifyVector(weight()) &&
2271 VerifyOffset(verifier, 12) &&
2272 verifier.VerifyVector(bias()) &&
2273 verifier.EndTable();
2274 }
2275 MatMulT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2276 void UnPackTo(MatMulT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2277 static flatbuffers::Offset<MatMul> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MatMulT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2278 };
2279
2280 struct MatMulBuilder {
2281 flatbuffers::FlatBufferBuilder &fbb_;
2282 flatbuffers::uoffset_t start_;
add_TMatMulBuilder2283 void add_T(DataType T) {
2284 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(T), 0);
2285 }
add_transposeAMatMulBuilder2286 void add_transposeA(bool transposeA) {
2287 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(transposeA), 0);
2288 }
add_transposeBMatMulBuilder2289 void add_transposeB(bool transposeB) {
2290 fbb_.AddElement<uint8_t>(8, static_cast<uint8_t>(transposeB), 0);
2291 }
add_weightMatMulBuilder2292 void add_weight(flatbuffers::Offset<flatbuffers::Vector<float>> weight) {
2293 fbb_.AddOffset(10, weight);
2294 }
add_biasMatMulBuilder2295 void add_bias(flatbuffers::Offset<flatbuffers::Vector<float>> bias) {
2296 fbb_.AddOffset(12, bias);
2297 }
MatMulBuilderMatMulBuilder2298 explicit MatMulBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2299 : fbb_(_fbb) {
2300 start_ = fbb_.StartTable();
2301 }
2302 MatMulBuilder &operator=(const MatMulBuilder &);
FinishMatMulBuilder2303 flatbuffers::Offset<MatMul> Finish() {
2304 const auto end = fbb_.EndTable(start_);
2305 auto o = flatbuffers::Offset<MatMul>(end);
2306 return o;
2307 }
2308 };
2309
2310 inline flatbuffers::Offset<MatMul> CreateMatMul(
2311 flatbuffers::FlatBufferBuilder &_fbb,
2312 DataType T = DataType_DT_INVALID,
2313 bool transposeA = false,
2314 bool transposeB = false,
2315 flatbuffers::Offset<flatbuffers::Vector<float>> weight = 0,
2316 flatbuffers::Offset<flatbuffers::Vector<float>> bias = 0) {
2317 MatMulBuilder builder_(_fbb);
2318 builder_.add_bias(bias);
2319 builder_.add_weight(weight);
2320 builder_.add_T(T);
2321 builder_.add_transposeB(transposeB);
2322 builder_.add_transposeA(transposeA);
2323 return builder_.Finish();
2324 }
2325
2326 flatbuffers::Offset<MatMul> CreateMatMul(flatbuffers::FlatBufferBuilder &_fbb, const MatMulT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2327
2328 struct MomentsParamT : public flatbuffers::NativeTable {
2329 typedef MomentsParam TableType;
2330 std::vector<int32_t> dim;
2331 bool keepDims;
2332 DataType dType;
MomentsParamTMomentsParamT2333 MomentsParamT()
2334 : keepDims(true),
2335 dType(DataType_DT_FLOAT) {
2336 }
2337 };
2338
2339 struct MomentsParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2340 typedef MomentsParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2341 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2342 return MomentsParamTypeTable();
2343 }
dimFLATBUFFERS_FINAL_CLASS2344 const flatbuffers::Vector<int32_t> *dim() const {
2345 return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
2346 }
keepDimsFLATBUFFERS_FINAL_CLASS2347 bool keepDims() const {
2348 return GetField<uint8_t>(6, 1) != 0;
2349 }
dTypeFLATBUFFERS_FINAL_CLASS2350 DataType dType() const {
2351 return static_cast<DataType>(GetField<int32_t>(8, 1));
2352 }
VerifyFLATBUFFERS_FINAL_CLASS2353 bool Verify(flatbuffers::Verifier &verifier) const {
2354 return VerifyTableStart(verifier) &&
2355 VerifyOffset(verifier, 4) &&
2356 verifier.VerifyVector(dim()) &&
2357 VerifyField<uint8_t>(verifier, 6) &&
2358 VerifyField<int32_t>(verifier, 8) &&
2359 verifier.EndTable();
2360 }
2361 MomentsParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2362 void UnPackTo(MomentsParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2363 static flatbuffers::Offset<MomentsParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MomentsParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2364 };
2365
2366 struct MomentsParamBuilder {
2367 flatbuffers::FlatBufferBuilder &fbb_;
2368 flatbuffers::uoffset_t start_;
add_dimMomentsParamBuilder2369 void add_dim(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dim) {
2370 fbb_.AddOffset(4, dim);
2371 }
add_keepDimsMomentsParamBuilder2372 void add_keepDims(bool keepDims) {
2373 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(keepDims), 1);
2374 }
add_dTypeMomentsParamBuilder2375 void add_dType(DataType dType) {
2376 fbb_.AddElement<int32_t>(8, static_cast<int32_t>(dType), 1);
2377 }
MomentsParamBuilderMomentsParamBuilder2378 explicit MomentsParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2379 : fbb_(_fbb) {
2380 start_ = fbb_.StartTable();
2381 }
2382 MomentsParamBuilder &operator=(const MomentsParamBuilder &);
FinishMomentsParamBuilder2383 flatbuffers::Offset<MomentsParam> Finish() {
2384 const auto end = fbb_.EndTable(start_);
2385 auto o = flatbuffers::Offset<MomentsParam>(end);
2386 return o;
2387 }
2388 };
2389
2390 inline flatbuffers::Offset<MomentsParam> CreateMomentsParam(
2391 flatbuffers::FlatBufferBuilder &_fbb,
2392 flatbuffers::Offset<flatbuffers::Vector<int32_t>> dim = 0,
2393 bool keepDims = true,
2394 DataType dType = DataType_DT_FLOAT) {
2395 MomentsParamBuilder builder_(_fbb);
2396 builder_.add_dType(dType);
2397 builder_.add_dim(dim);
2398 builder_.add_keepDims(keepDims);
2399 return builder_.Finish();
2400 }
2401
2402 flatbuffers::Offset<MomentsParam> CreateMomentsParam(flatbuffers::FlatBufferBuilder &_fbb, const MomentsParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2403
2404 struct RNNParamT : public flatbuffers::NativeTable {
2405 typedef RNNParam TableType;
2406 int32_t numUnits;
2407 bool isBidirectionalRNN;
2408 bool linearBeforeReset;
2409 bool keepAllOutputs;
2410 std::unique_ptr<BlobT> fwGateWeight;
2411 std::unique_ptr<BlobT> fwGateBias;
2412 std::unique_ptr<BlobT> fwCandidateWeight;
2413 std::unique_ptr<BlobT> fwCandidateBias;
2414 std::unique_ptr<BlobT> fwRecurrentBias;
2415 std::unique_ptr<BlobT> bwGateWeight;
2416 std::unique_ptr<BlobT> bwGateBias;
2417 std::unique_ptr<BlobT> bwCandidateWeight;
2418 std::unique_ptr<BlobT> bwCandidateBias;
2419 std::unique_ptr<BlobT> bwRecurrentBias;
RNNParamTRNNParamT2420 RNNParamT()
2421 : numUnits(0),
2422 isBidirectionalRNN(false),
2423 linearBeforeReset(false),
2424 keepAllOutputs(false) {
2425 }
2426 };
2427
2428 struct RNNParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2429 typedef RNNParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2430 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2431 return RNNParamTypeTable();
2432 }
numUnitsFLATBUFFERS_FINAL_CLASS2433 int32_t numUnits() const {
2434 return GetField<int32_t>(4, 0);
2435 }
isBidirectionalRNNFLATBUFFERS_FINAL_CLASS2436 bool isBidirectionalRNN() const {
2437 return GetField<uint8_t>(6, 0) != 0;
2438 }
linearBeforeResetFLATBUFFERS_FINAL_CLASS2439 bool linearBeforeReset() const {
2440 return GetField<uint8_t>(8, 0) != 0;
2441 }
keepAllOutputsFLATBUFFERS_FINAL_CLASS2442 bool keepAllOutputs() const {
2443 return GetField<uint8_t>(10, 0) != 0;
2444 }
fwGateWeightFLATBUFFERS_FINAL_CLASS2445 const Blob *fwGateWeight() const {
2446 return GetPointer<const Blob *>(12);
2447 }
fwGateBiasFLATBUFFERS_FINAL_CLASS2448 const Blob *fwGateBias() const {
2449 return GetPointer<const Blob *>(14);
2450 }
fwCandidateWeightFLATBUFFERS_FINAL_CLASS2451 const Blob *fwCandidateWeight() const {
2452 return GetPointer<const Blob *>(16);
2453 }
fwCandidateBiasFLATBUFFERS_FINAL_CLASS2454 const Blob *fwCandidateBias() const {
2455 return GetPointer<const Blob *>(18);
2456 }
fwRecurrentBiasFLATBUFFERS_FINAL_CLASS2457 const Blob *fwRecurrentBias() const {
2458 return GetPointer<const Blob *>(20);
2459 }
bwGateWeightFLATBUFFERS_FINAL_CLASS2460 const Blob *bwGateWeight() const {
2461 return GetPointer<const Blob *>(22);
2462 }
bwGateBiasFLATBUFFERS_FINAL_CLASS2463 const Blob *bwGateBias() const {
2464 return GetPointer<const Blob *>(24);
2465 }
bwCandidateWeightFLATBUFFERS_FINAL_CLASS2466 const Blob *bwCandidateWeight() const {
2467 return GetPointer<const Blob *>(26);
2468 }
bwCandidateBiasFLATBUFFERS_FINAL_CLASS2469 const Blob *bwCandidateBias() const {
2470 return GetPointer<const Blob *>(28);
2471 }
bwRecurrentBiasFLATBUFFERS_FINAL_CLASS2472 const Blob *bwRecurrentBias() const {
2473 return GetPointer<const Blob *>(30);
2474 }
VerifyFLATBUFFERS_FINAL_CLASS2475 bool Verify(flatbuffers::Verifier &verifier) const {
2476 return VerifyTableStart(verifier) &&
2477 VerifyField<int32_t>(verifier, 4) &&
2478 VerifyField<uint8_t>(verifier, 6) &&
2479 VerifyField<uint8_t>(verifier, 8) &&
2480 VerifyField<uint8_t>(verifier, 10) &&
2481 VerifyOffset(verifier, 12) &&
2482 verifier.VerifyTable(fwGateWeight()) &&
2483 VerifyOffset(verifier, 14) &&
2484 verifier.VerifyTable(fwGateBias()) &&
2485 VerifyOffset(verifier, 16) &&
2486 verifier.VerifyTable(fwCandidateWeight()) &&
2487 VerifyOffset(verifier, 18) &&
2488 verifier.VerifyTable(fwCandidateBias()) &&
2489 VerifyOffset(verifier, 20) &&
2490 verifier.VerifyTable(fwRecurrentBias()) &&
2491 VerifyOffset(verifier, 22) &&
2492 verifier.VerifyTable(bwGateWeight()) &&
2493 VerifyOffset(verifier, 24) &&
2494 verifier.VerifyTable(bwGateBias()) &&
2495 VerifyOffset(verifier, 26) &&
2496 verifier.VerifyTable(bwCandidateWeight()) &&
2497 VerifyOffset(verifier, 28) &&
2498 verifier.VerifyTable(bwCandidateBias()) &&
2499 VerifyOffset(verifier, 30) &&
2500 verifier.VerifyTable(bwRecurrentBias()) &&
2501 verifier.EndTable();
2502 }
2503 RNNParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2504 void UnPackTo(RNNParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2505 static flatbuffers::Offset<RNNParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2506 };
2507
2508 struct RNNParamBuilder {
2509 flatbuffers::FlatBufferBuilder &fbb_;
2510 flatbuffers::uoffset_t start_;
add_numUnitsRNNParamBuilder2511 void add_numUnits(int32_t numUnits) {
2512 fbb_.AddElement<int32_t>(4, numUnits, 0);
2513 }
add_isBidirectionalRNNRNNParamBuilder2514 void add_isBidirectionalRNN(bool isBidirectionalRNN) {
2515 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(isBidirectionalRNN), 0);
2516 }
add_linearBeforeResetRNNParamBuilder2517 void add_linearBeforeReset(bool linearBeforeReset) {
2518 fbb_.AddElement<uint8_t>(8, static_cast<uint8_t>(linearBeforeReset), 0);
2519 }
add_keepAllOutputsRNNParamBuilder2520 void add_keepAllOutputs(bool keepAllOutputs) {
2521 fbb_.AddElement<uint8_t>(10, static_cast<uint8_t>(keepAllOutputs), 0);
2522 }
add_fwGateWeightRNNParamBuilder2523 void add_fwGateWeight(flatbuffers::Offset<Blob> fwGateWeight) {
2524 fbb_.AddOffset(12, fwGateWeight);
2525 }
add_fwGateBiasRNNParamBuilder2526 void add_fwGateBias(flatbuffers::Offset<Blob> fwGateBias) {
2527 fbb_.AddOffset(14, fwGateBias);
2528 }
add_fwCandidateWeightRNNParamBuilder2529 void add_fwCandidateWeight(flatbuffers::Offset<Blob> fwCandidateWeight) {
2530 fbb_.AddOffset(16, fwCandidateWeight);
2531 }
add_fwCandidateBiasRNNParamBuilder2532 void add_fwCandidateBias(flatbuffers::Offset<Blob> fwCandidateBias) {
2533 fbb_.AddOffset(18, fwCandidateBias);
2534 }
add_fwRecurrentBiasRNNParamBuilder2535 void add_fwRecurrentBias(flatbuffers::Offset<Blob> fwRecurrentBias) {
2536 fbb_.AddOffset(20, fwRecurrentBias);
2537 }
add_bwGateWeightRNNParamBuilder2538 void add_bwGateWeight(flatbuffers::Offset<Blob> bwGateWeight) {
2539 fbb_.AddOffset(22, bwGateWeight);
2540 }
add_bwGateBiasRNNParamBuilder2541 void add_bwGateBias(flatbuffers::Offset<Blob> bwGateBias) {
2542 fbb_.AddOffset(24, bwGateBias);
2543 }
add_bwCandidateWeightRNNParamBuilder2544 void add_bwCandidateWeight(flatbuffers::Offset<Blob> bwCandidateWeight) {
2545 fbb_.AddOffset(26, bwCandidateWeight);
2546 }
add_bwCandidateBiasRNNParamBuilder2547 void add_bwCandidateBias(flatbuffers::Offset<Blob> bwCandidateBias) {
2548 fbb_.AddOffset(28, bwCandidateBias);
2549 }
add_bwRecurrentBiasRNNParamBuilder2550 void add_bwRecurrentBias(flatbuffers::Offset<Blob> bwRecurrentBias) {
2551 fbb_.AddOffset(30, bwRecurrentBias);
2552 }
RNNParamBuilderRNNParamBuilder2553 explicit RNNParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2554 : fbb_(_fbb) {
2555 start_ = fbb_.StartTable();
2556 }
2557 RNNParamBuilder &operator=(const RNNParamBuilder &);
FinishRNNParamBuilder2558 flatbuffers::Offset<RNNParam> Finish() {
2559 const auto end = fbb_.EndTable(start_);
2560 auto o = flatbuffers::Offset<RNNParam>(end);
2561 return o;
2562 }
2563 };
2564
2565 inline flatbuffers::Offset<RNNParam> CreateRNNParam(
2566 flatbuffers::FlatBufferBuilder &_fbb,
2567 int32_t numUnits = 0,
2568 bool isBidirectionalRNN = false,
2569 bool linearBeforeReset = false,
2570 bool keepAllOutputs = false,
2571 flatbuffers::Offset<Blob> fwGateWeight = 0,
2572 flatbuffers::Offset<Blob> fwGateBias = 0,
2573 flatbuffers::Offset<Blob> fwCandidateWeight = 0,
2574 flatbuffers::Offset<Blob> fwCandidateBias = 0,
2575 flatbuffers::Offset<Blob> fwRecurrentBias = 0,
2576 flatbuffers::Offset<Blob> bwGateWeight = 0,
2577 flatbuffers::Offset<Blob> bwGateBias = 0,
2578 flatbuffers::Offset<Blob> bwCandidateWeight = 0,
2579 flatbuffers::Offset<Blob> bwCandidateBias = 0,
2580 flatbuffers::Offset<Blob> bwRecurrentBias = 0) {
2581 RNNParamBuilder builder_(_fbb);
2582 builder_.add_bwRecurrentBias(bwRecurrentBias);
2583 builder_.add_bwCandidateBias(bwCandidateBias);
2584 builder_.add_bwCandidateWeight(bwCandidateWeight);
2585 builder_.add_bwGateBias(bwGateBias);
2586 builder_.add_bwGateWeight(bwGateWeight);
2587 builder_.add_fwRecurrentBias(fwRecurrentBias);
2588 builder_.add_fwCandidateBias(fwCandidateBias);
2589 builder_.add_fwCandidateWeight(fwCandidateWeight);
2590 builder_.add_fwGateBias(fwGateBias);
2591 builder_.add_fwGateWeight(fwGateWeight);
2592 builder_.add_numUnits(numUnits);
2593 builder_.add_keepAllOutputs(keepAllOutputs);
2594 builder_.add_linearBeforeReset(linearBeforeReset);
2595 builder_.add_isBidirectionalRNN(isBidirectionalRNN);
2596 return builder_.Finish();
2597 }
2598
2599 flatbuffers::Offset<RNNParam> CreateRNNParam(flatbuffers::FlatBufferBuilder &_fbb, const RNNParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2600
2601 struct BatchMatMulParamT : public flatbuffers::NativeTable {
2602 typedef BatchMatMulParam TableType;
2603 bool adjX;
2604 bool adjY;
BatchMatMulParamTBatchMatMulParamT2605 BatchMatMulParamT()
2606 : adjX(false),
2607 adjY(false) {
2608 }
2609 };
2610
2611 struct BatchMatMulParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2612 typedef BatchMatMulParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2613 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2614 return BatchMatMulParamTypeTable();
2615 }
adjXFLATBUFFERS_FINAL_CLASS2616 bool adjX() const {
2617 return GetField<uint8_t>(4, 0) != 0;
2618 }
adjYFLATBUFFERS_FINAL_CLASS2619 bool adjY() const {
2620 return GetField<uint8_t>(6, 0) != 0;
2621 }
VerifyFLATBUFFERS_FINAL_CLASS2622 bool Verify(flatbuffers::Verifier &verifier) const {
2623 return VerifyTableStart(verifier) &&
2624 VerifyField<uint8_t>(verifier, 4) &&
2625 VerifyField<uint8_t>(verifier, 6) &&
2626 verifier.EndTable();
2627 }
2628 BatchMatMulParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2629 void UnPackTo(BatchMatMulParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2630 static flatbuffers::Offset<BatchMatMulParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2631 };
2632
2633 struct BatchMatMulParamBuilder {
2634 flatbuffers::FlatBufferBuilder &fbb_;
2635 flatbuffers::uoffset_t start_;
add_adjXBatchMatMulParamBuilder2636 void add_adjX(bool adjX) {
2637 fbb_.AddElement<uint8_t>(4, static_cast<uint8_t>(adjX), 0);
2638 }
add_adjYBatchMatMulParamBuilder2639 void add_adjY(bool adjY) {
2640 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(adjY), 0);
2641 }
BatchMatMulParamBuilderBatchMatMulParamBuilder2642 explicit BatchMatMulParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2643 : fbb_(_fbb) {
2644 start_ = fbb_.StartTable();
2645 }
2646 BatchMatMulParamBuilder &operator=(const BatchMatMulParamBuilder &);
FinishBatchMatMulParamBuilder2647 flatbuffers::Offset<BatchMatMulParam> Finish() {
2648 const auto end = fbb_.EndTable(start_);
2649 auto o = flatbuffers::Offset<BatchMatMulParam>(end);
2650 return o;
2651 }
2652 };
2653
2654 inline flatbuffers::Offset<BatchMatMulParam> CreateBatchMatMulParam(
2655 flatbuffers::FlatBufferBuilder &_fbb,
2656 bool adjX = false,
2657 bool adjY = false) {
2658 BatchMatMulParamBuilder builder_(_fbb);
2659 builder_.add_adjY(adjY);
2660 builder_.add_adjX(adjX);
2661 return builder_.Finish();
2662 }
2663
2664 flatbuffers::Offset<BatchMatMulParam> CreateBatchMatMulParam(flatbuffers::FlatBufferBuilder &_fbb, const BatchMatMulParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2665
2666 struct DepthSpaceParamT : public flatbuffers::NativeTable {
2667 typedef DepthSpaceParam TableType;
2668 int32_t blockSize;
2669 DepthToSpaceMode mode;
DepthSpaceParamTDepthSpaceParamT2670 DepthSpaceParamT()
2671 : blockSize(0),
2672 mode(DepthToSpaceMode_DCR) {
2673 }
2674 };
2675
2676 struct DepthSpaceParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2677 typedef DepthSpaceParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2678 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2679 return DepthSpaceParamTypeTable();
2680 }
blockSizeFLATBUFFERS_FINAL_CLASS2681 int32_t blockSize() const {
2682 return GetField<int32_t>(4, 0);
2683 }
modeFLATBUFFERS_FINAL_CLASS2684 DepthToSpaceMode mode() const {
2685 return static_cast<DepthToSpaceMode>(GetField<int8_t>(6, 0));
2686 }
VerifyFLATBUFFERS_FINAL_CLASS2687 bool Verify(flatbuffers::Verifier &verifier) const {
2688 return VerifyTableStart(verifier) &&
2689 VerifyField<int32_t>(verifier, 4) &&
2690 VerifyField<int8_t>(verifier, 6) &&
2691 verifier.EndTable();
2692 }
2693 DepthSpaceParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2694 void UnPackTo(DepthSpaceParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2695 static flatbuffers::Offset<DepthSpaceParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthSpaceParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2696 };
2697
2698 struct DepthSpaceParamBuilder {
2699 flatbuffers::FlatBufferBuilder &fbb_;
2700 flatbuffers::uoffset_t start_;
add_blockSizeDepthSpaceParamBuilder2701 void add_blockSize(int32_t blockSize) {
2702 fbb_.AddElement<int32_t>(4, blockSize, 0);
2703 }
add_modeDepthSpaceParamBuilder2704 void add_mode(DepthToSpaceMode mode) {
2705 fbb_.AddElement<int8_t>(6, static_cast<int8_t>(mode), 0);
2706 }
DepthSpaceParamBuilderDepthSpaceParamBuilder2707 explicit DepthSpaceParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2708 : fbb_(_fbb) {
2709 start_ = fbb_.StartTable();
2710 }
2711 DepthSpaceParamBuilder &operator=(const DepthSpaceParamBuilder &);
FinishDepthSpaceParamBuilder2712 flatbuffers::Offset<DepthSpaceParam> Finish() {
2713 const auto end = fbb_.EndTable(start_);
2714 auto o = flatbuffers::Offset<DepthSpaceParam>(end);
2715 return o;
2716 }
2717 };
2718
2719 inline flatbuffers::Offset<DepthSpaceParam> CreateDepthSpaceParam(
2720 flatbuffers::FlatBufferBuilder &_fbb,
2721 int32_t blockSize = 0,
2722 DepthToSpaceMode mode = DepthToSpaceMode_DCR) {
2723 DepthSpaceParamBuilder builder_(_fbb);
2724 builder_.add_blockSize(blockSize);
2725 builder_.add_mode(mode);
2726 return builder_.Finish();
2727 }
2728
2729 flatbuffers::Offset<DepthSpaceParam> CreateDepthSpaceParam(flatbuffers::FlatBufferBuilder &_fbb, const DepthSpaceParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2730
2731 struct ReverseSequenceParamT : public flatbuffers::NativeTable {
2732 typedef ReverseSequenceParam TableType;
2733 int32_t batchDim;
2734 int32_t seqDim;
ReverseSequenceParamTReverseSequenceParamT2735 ReverseSequenceParamT()
2736 : batchDim(0),
2737 seqDim(0) {
2738 }
2739 };
2740
2741 struct ReverseSequenceParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2742 typedef ReverseSequenceParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2743 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2744 return ReverseSequenceParamTypeTable();
2745 }
batchDimFLATBUFFERS_FINAL_CLASS2746 int32_t batchDim() const {
2747 return GetField<int32_t>(4, 0);
2748 }
seqDimFLATBUFFERS_FINAL_CLASS2749 int32_t seqDim() const {
2750 return GetField<int32_t>(6, 0);
2751 }
VerifyFLATBUFFERS_FINAL_CLASS2752 bool Verify(flatbuffers::Verifier &verifier) const {
2753 return VerifyTableStart(verifier) &&
2754 VerifyField<int32_t>(verifier, 4) &&
2755 VerifyField<int32_t>(verifier, 6) &&
2756 verifier.EndTable();
2757 }
2758 ReverseSequenceParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2759 void UnPackTo(ReverseSequenceParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2760 static flatbuffers::Offset<ReverseSequenceParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2761 };
2762
2763 struct ReverseSequenceParamBuilder {
2764 flatbuffers::FlatBufferBuilder &fbb_;
2765 flatbuffers::uoffset_t start_;
add_batchDimReverseSequenceParamBuilder2766 void add_batchDim(int32_t batchDim) {
2767 fbb_.AddElement<int32_t>(4, batchDim, 0);
2768 }
add_seqDimReverseSequenceParamBuilder2769 void add_seqDim(int32_t seqDim) {
2770 fbb_.AddElement<int32_t>(6, seqDim, 0);
2771 }
ReverseSequenceParamBuilderReverseSequenceParamBuilder2772 explicit ReverseSequenceParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2773 : fbb_(_fbb) {
2774 start_ = fbb_.StartTable();
2775 }
2776 ReverseSequenceParamBuilder &operator=(const ReverseSequenceParamBuilder &);
FinishReverseSequenceParamBuilder2777 flatbuffers::Offset<ReverseSequenceParam> Finish() {
2778 const auto end = fbb_.EndTable(start_);
2779 auto o = flatbuffers::Offset<ReverseSequenceParam>(end);
2780 return o;
2781 }
2782 };
2783
2784 inline flatbuffers::Offset<ReverseSequenceParam> CreateReverseSequenceParam(
2785 flatbuffers::FlatBufferBuilder &_fbb,
2786 int32_t batchDim = 0,
2787 int32_t seqDim = 0) {
2788 ReverseSequenceParamBuilder builder_(_fbb);
2789 builder_.add_seqDim(seqDim);
2790 builder_.add_batchDim(batchDim);
2791 return builder_.Finish();
2792 }
2793
2794 flatbuffers::Offset<ReverseSequenceParam> CreateReverseSequenceParam(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2795
2796 struct DetectionPostProcessParamT : public flatbuffers::NativeTable {
2797 typedef DetectionPostProcessParam TableType;
2798 int32_t maxDetections;
2799 int32_t maxClassesPerDetection;
2800 int32_t detectionsPerClass;
2801 float nmsScoreThreshold;
2802 float iouThreshold;
2803 int32_t numClasses;
2804 bool useRegularNMS;
2805 std::vector<float> centerSizeEncoding;
DetectionPostProcessParamTDetectionPostProcessParamT2806 DetectionPostProcessParamT()
2807 : maxDetections(0),
2808 maxClassesPerDetection(0),
2809 detectionsPerClass(0),
2810 nmsScoreThreshold(0.0f),
2811 iouThreshold(0.0f),
2812 numClasses(0),
2813 useRegularNMS(false) {
2814 }
2815 };
2816
2817 struct DetectionPostProcessParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2818 typedef DetectionPostProcessParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2819 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2820 return DetectionPostProcessParamTypeTable();
2821 }
maxDetectionsFLATBUFFERS_FINAL_CLASS2822 int32_t maxDetections() const {
2823 return GetField<int32_t>(4, 0);
2824 }
maxClassesPerDetectionFLATBUFFERS_FINAL_CLASS2825 int32_t maxClassesPerDetection() const {
2826 return GetField<int32_t>(6, 0);
2827 }
detectionsPerClassFLATBUFFERS_FINAL_CLASS2828 int32_t detectionsPerClass() const {
2829 return GetField<int32_t>(8, 0);
2830 }
nmsScoreThresholdFLATBUFFERS_FINAL_CLASS2831 float nmsScoreThreshold() const {
2832 return GetField<float>(10, 0.0f);
2833 }
iouThresholdFLATBUFFERS_FINAL_CLASS2834 float iouThreshold() const {
2835 return GetField<float>(12, 0.0f);
2836 }
numClassesFLATBUFFERS_FINAL_CLASS2837 int32_t numClasses() const {
2838 return GetField<int32_t>(14, 0);
2839 }
useRegularNMSFLATBUFFERS_FINAL_CLASS2840 bool useRegularNMS() const {
2841 return GetField<uint8_t>(16, 0) != 0;
2842 }
centerSizeEncodingFLATBUFFERS_FINAL_CLASS2843 const flatbuffers::Vector<float> *centerSizeEncoding() const {
2844 return GetPointer<const flatbuffers::Vector<float> *>(18);
2845 }
VerifyFLATBUFFERS_FINAL_CLASS2846 bool Verify(flatbuffers::Verifier &verifier) const {
2847 return VerifyTableStart(verifier) &&
2848 VerifyField<int32_t>(verifier, 4) &&
2849 VerifyField<int32_t>(verifier, 6) &&
2850 VerifyField<int32_t>(verifier, 8) &&
2851 VerifyField<float>(verifier, 10) &&
2852 VerifyField<float>(verifier, 12) &&
2853 VerifyField<int32_t>(verifier, 14) &&
2854 VerifyField<uint8_t>(verifier, 16) &&
2855 VerifyOffset(verifier, 18) &&
2856 verifier.VerifyVector(centerSizeEncoding()) &&
2857 verifier.EndTable();
2858 }
2859 DetectionPostProcessParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2860 void UnPackTo(DetectionPostProcessParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2861 static flatbuffers::Offset<DetectionPostProcessParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DetectionPostProcessParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2862 };
2863
2864 struct DetectionPostProcessParamBuilder {
2865 flatbuffers::FlatBufferBuilder &fbb_;
2866 flatbuffers::uoffset_t start_;
add_maxDetectionsDetectionPostProcessParamBuilder2867 void add_maxDetections(int32_t maxDetections) {
2868 fbb_.AddElement<int32_t>(4, maxDetections, 0);
2869 }
add_maxClassesPerDetectionDetectionPostProcessParamBuilder2870 void add_maxClassesPerDetection(int32_t maxClassesPerDetection) {
2871 fbb_.AddElement<int32_t>(6, maxClassesPerDetection, 0);
2872 }
add_detectionsPerClassDetectionPostProcessParamBuilder2873 void add_detectionsPerClass(int32_t detectionsPerClass) {
2874 fbb_.AddElement<int32_t>(8, detectionsPerClass, 0);
2875 }
add_nmsScoreThresholdDetectionPostProcessParamBuilder2876 void add_nmsScoreThreshold(float nmsScoreThreshold) {
2877 fbb_.AddElement<float>(10, nmsScoreThreshold, 0.0f);
2878 }
add_iouThresholdDetectionPostProcessParamBuilder2879 void add_iouThreshold(float iouThreshold) {
2880 fbb_.AddElement<float>(12, iouThreshold, 0.0f);
2881 }
add_numClassesDetectionPostProcessParamBuilder2882 void add_numClasses(int32_t numClasses) {
2883 fbb_.AddElement<int32_t>(14, numClasses, 0);
2884 }
add_useRegularNMSDetectionPostProcessParamBuilder2885 void add_useRegularNMS(bool useRegularNMS) {
2886 fbb_.AddElement<uint8_t>(16, static_cast<uint8_t>(useRegularNMS), 0);
2887 }
add_centerSizeEncodingDetectionPostProcessParamBuilder2888 void add_centerSizeEncoding(flatbuffers::Offset<flatbuffers::Vector<float>> centerSizeEncoding) {
2889 fbb_.AddOffset(18, centerSizeEncoding);
2890 }
DetectionPostProcessParamBuilderDetectionPostProcessParamBuilder2891 explicit DetectionPostProcessParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2892 : fbb_(_fbb) {
2893 start_ = fbb_.StartTable();
2894 }
2895 DetectionPostProcessParamBuilder &operator=(const DetectionPostProcessParamBuilder &);
FinishDetectionPostProcessParamBuilder2896 flatbuffers::Offset<DetectionPostProcessParam> Finish() {
2897 const auto end = fbb_.EndTable(start_);
2898 auto o = flatbuffers::Offset<DetectionPostProcessParam>(end);
2899 return o;
2900 }
2901 };
2902
2903 inline flatbuffers::Offset<DetectionPostProcessParam> CreateDetectionPostProcessParam(
2904 flatbuffers::FlatBufferBuilder &_fbb,
2905 int32_t maxDetections = 0,
2906 int32_t maxClassesPerDetection = 0,
2907 int32_t detectionsPerClass = 0,
2908 float nmsScoreThreshold = 0.0f,
2909 float iouThreshold = 0.0f,
2910 int32_t numClasses = 0,
2911 bool useRegularNMS = false,
2912 flatbuffers::Offset<flatbuffers::Vector<float>> centerSizeEncoding = 0) {
2913 DetectionPostProcessParamBuilder builder_(_fbb);
2914 builder_.add_centerSizeEncoding(centerSizeEncoding);
2915 builder_.add_numClasses(numClasses);
2916 builder_.add_iouThreshold(iouThreshold);
2917 builder_.add_nmsScoreThreshold(nmsScoreThreshold);
2918 builder_.add_detectionsPerClass(detectionsPerClass);
2919 builder_.add_maxClassesPerDetection(maxClassesPerDetection);
2920 builder_.add_maxDetections(maxDetections);
2921 builder_.add_useRegularNMS(useRegularNMS);
2922 return builder_.Finish();
2923 }
2924
2925 flatbuffers::Offset<DetectionPostProcessParam> CreateDetectionPostProcessParam(flatbuffers::FlatBufferBuilder &_fbb, const DetectionPostProcessParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2926
2927 struct OneHotParamT : public flatbuffers::NativeTable {
2928 typedef OneHotParam TableType;
2929 DataType dType;
2930 int32_t axis;
OneHotParamTOneHotParamT2931 OneHotParamT()
2932 : dType(DataType_DT_FLOAT),
2933 axis(-1) {
2934 }
2935 };
2936
2937 struct OneHotParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2938 typedef OneHotParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS2939 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
2940 return OneHotParamTypeTable();
2941 }
dTypeFLATBUFFERS_FINAL_CLASS2942 DataType dType() const {
2943 return static_cast<DataType>(GetField<int32_t>(4, 1));
2944 }
axisFLATBUFFERS_FINAL_CLASS2945 int32_t axis() const {
2946 return GetField<int32_t>(6, -1);
2947 }
VerifyFLATBUFFERS_FINAL_CLASS2948 bool Verify(flatbuffers::Verifier &verifier) const {
2949 return VerifyTableStart(verifier) &&
2950 VerifyField<int32_t>(verifier, 4) &&
2951 VerifyField<int32_t>(verifier, 6) &&
2952 verifier.EndTable();
2953 }
2954 OneHotParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2955 void UnPackTo(OneHotParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2956 static flatbuffers::Offset<OneHotParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2957 };
2958
2959 struct OneHotParamBuilder {
2960 flatbuffers::FlatBufferBuilder &fbb_;
2961 flatbuffers::uoffset_t start_;
add_dTypeOneHotParamBuilder2962 void add_dType(DataType dType) {
2963 fbb_.AddElement<int32_t>(4, static_cast<int32_t>(dType), 1);
2964 }
add_axisOneHotParamBuilder2965 void add_axis(int32_t axis) {
2966 fbb_.AddElement<int32_t>(6, axis, -1);
2967 }
OneHotParamBuilderOneHotParamBuilder2968 explicit OneHotParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2969 : fbb_(_fbb) {
2970 start_ = fbb_.StartTable();
2971 }
2972 OneHotParamBuilder &operator=(const OneHotParamBuilder &);
FinishOneHotParamBuilder2973 flatbuffers::Offset<OneHotParam> Finish() {
2974 const auto end = fbb_.EndTable(start_);
2975 auto o = flatbuffers::Offset<OneHotParam>(end);
2976 return o;
2977 }
2978 };
2979
2980 inline flatbuffers::Offset<OneHotParam> CreateOneHotParam(
2981 flatbuffers::FlatBufferBuilder &_fbb,
2982 DataType dType = DataType_DT_FLOAT,
2983 int32_t axis = -1) {
2984 OneHotParamBuilder builder_(_fbb);
2985 builder_.add_axis(axis);
2986 builder_.add_dType(dType);
2987 return builder_.Finish();
2988 }
2989
2990 flatbuffers::Offset<OneHotParam> CreateOneHotParam(flatbuffers::FlatBufferBuilder &_fbb, const OneHotParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2991
2992 struct PadParamT : public flatbuffers::NativeTable {
2993 typedef PadParam TableType;
2994 PadValueMode mode;
PadParamTPadParamT2995 PadParamT()
2996 : mode(PadValueMode_CONSTANT) {
2997 }
2998 };
2999
3000 struct PadParam FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3001 typedef PadParamT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS3002 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
3003 return PadParamTypeTable();
3004 }
modeFLATBUFFERS_FINAL_CLASS3005 PadValueMode mode() const {
3006 return static_cast<PadValueMode>(GetField<int8_t>(4, 0));
3007 }
VerifyFLATBUFFERS_FINAL_CLASS3008 bool Verify(flatbuffers::Verifier &verifier) const {
3009 return VerifyTableStart(verifier) &&
3010 VerifyField<int8_t>(verifier, 4) &&
3011 verifier.EndTable();
3012 }
3013 PadParamT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3014 void UnPackTo(PadParamT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3015 static flatbuffers::Offset<PadParam> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadParamT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3016 };
3017
3018 struct PadParamBuilder {
3019 flatbuffers::FlatBufferBuilder &fbb_;
3020 flatbuffers::uoffset_t start_;
add_modePadParamBuilder3021 void add_mode(PadValueMode mode) {
3022 fbb_.AddElement<int8_t>(4, static_cast<int8_t>(mode), 0);
3023 }
PadParamBuilderPadParamBuilder3024 explicit PadParamBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3025 : fbb_(_fbb) {
3026 start_ = fbb_.StartTable();
3027 }
3028 PadParamBuilder &operator=(const PadParamBuilder &);
FinishPadParamBuilder3029 flatbuffers::Offset<PadParam> Finish() {
3030 const auto end = fbb_.EndTable(start_);
3031 auto o = flatbuffers::Offset<PadParam>(end);
3032 return o;
3033 }
3034 };
3035
3036 inline flatbuffers::Offset<PadParam> CreatePadParam(
3037 flatbuffers::FlatBufferBuilder &_fbb,
3038 PadValueMode mode = PadValueMode_CONSTANT) {
3039 PadParamBuilder builder_(_fbb);
3040 builder_.add_mode(mode);
3041 return builder_.Finish();
3042 }
3043
3044 flatbuffers::Offset<PadParam> CreatePadParam(flatbuffers::FlatBufferBuilder &_fbb, const PadParamT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3045
3046 struct LayerNormT : public flatbuffers::NativeTable {
3047 typedef LayerNorm TableType;
3048 std::vector<int32_t> axis;
3049 float epsilon;
3050 std::vector<float> gamma;
3051 std::vector<float> beta;
LayerNormTLayerNormT3052 LayerNormT()
3053 : epsilon(0.0f) {
3054 }
3055 };
3056
3057 struct LayerNorm FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3058 typedef LayerNormT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS3059 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
3060 return LayerNormTypeTable();
3061 }
axisFLATBUFFERS_FINAL_CLASS3062 const flatbuffers::Vector<int32_t> *axis() const {
3063 return GetPointer<const flatbuffers::Vector<int32_t> *>(4);
3064 }
epsilonFLATBUFFERS_FINAL_CLASS3065 float epsilon() const {
3066 return GetField<float>(6, 0.0f);
3067 }
gammaFLATBUFFERS_FINAL_CLASS3068 const flatbuffers::Vector<float> *gamma() const {
3069 return GetPointer<const flatbuffers::Vector<float> *>(8);
3070 }
betaFLATBUFFERS_FINAL_CLASS3071 const flatbuffers::Vector<float> *beta() const {
3072 return GetPointer<const flatbuffers::Vector<float> *>(10);
3073 }
VerifyFLATBUFFERS_FINAL_CLASS3074 bool Verify(flatbuffers::Verifier &verifier) const {
3075 return VerifyTableStart(verifier) &&
3076 VerifyOffset(verifier, 4) &&
3077 verifier.VerifyVector(axis()) &&
3078 VerifyField<float>(verifier, 6) &&
3079 VerifyOffset(verifier, 8) &&
3080 verifier.VerifyVector(gamma()) &&
3081 VerifyOffset(verifier, 10) &&
3082 verifier.VerifyVector(beta()) &&
3083 verifier.EndTable();
3084 }
3085 LayerNormT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3086 void UnPackTo(LayerNormT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3087 static flatbuffers::Offset<LayerNorm> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LayerNormT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3088 };
3089
3090 struct LayerNormBuilder {
3091 flatbuffers::FlatBufferBuilder &fbb_;
3092 flatbuffers::uoffset_t start_;
add_axisLayerNormBuilder3093 void add_axis(flatbuffers::Offset<flatbuffers::Vector<int32_t>> axis) {
3094 fbb_.AddOffset(4, axis);
3095 }
add_epsilonLayerNormBuilder3096 void add_epsilon(float epsilon) {
3097 fbb_.AddElement<float>(6, epsilon, 0.0f);
3098 }
add_gammaLayerNormBuilder3099 void add_gamma(flatbuffers::Offset<flatbuffers::Vector<float>> gamma) {
3100 fbb_.AddOffset(8, gamma);
3101 }
add_betaLayerNormBuilder3102 void add_beta(flatbuffers::Offset<flatbuffers::Vector<float>> beta) {
3103 fbb_.AddOffset(10, beta);
3104 }
LayerNormBuilderLayerNormBuilder3105 explicit LayerNormBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3106 : fbb_(_fbb) {
3107 start_ = fbb_.StartTable();
3108 }
3109 LayerNormBuilder &operator=(const LayerNormBuilder &);
FinishLayerNormBuilder3110 flatbuffers::Offset<LayerNorm> Finish() {
3111 const auto end = fbb_.EndTable(start_);
3112 auto o = flatbuffers::Offset<LayerNorm>(end);
3113 return o;
3114 }
3115 };
3116
3117 inline flatbuffers::Offset<LayerNorm> CreateLayerNorm(
3118 flatbuffers::FlatBufferBuilder &_fbb,
3119 flatbuffers::Offset<flatbuffers::Vector<int32_t>> axis = 0,
3120 float epsilon = 0.0f,
3121 flatbuffers::Offset<flatbuffers::Vector<float>> gamma = 0,
3122 flatbuffers::Offset<flatbuffers::Vector<float>> beta = 0) {
3123 LayerNormBuilder builder_(_fbb);
3124 builder_.add_beta(beta);
3125 builder_.add_gamma(gamma);
3126 builder_.add_epsilon(epsilon);
3127 builder_.add_axis(axis);
3128 return builder_.Finish();
3129 }
3130
3131 flatbuffers::Offset<LayerNorm> CreateLayerNorm(flatbuffers::FlatBufferBuilder &_fbb, const LayerNormT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3132
3133 struct RandomUniformT : public flatbuffers::NativeTable {
3134 typedef RandomUniform TableType;
3135 int32_t seed;
3136 int32_t seed2;
3137 DataType type;
3138 float low;
3139 float high;
RandomUniformTRandomUniformT3140 RandomUniformT()
3141 : seed(0),
3142 seed2(0),
3143 type(DataType_DT_FLOAT),
3144 low(0.0f),
3145 high(1.0f) {
3146 }
3147 };
3148
3149 struct RandomUniform FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3150 typedef RandomUniformT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS3151 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
3152 return RandomUniformTypeTable();
3153 }
seedFLATBUFFERS_FINAL_CLASS3154 int32_t seed() const {
3155 return GetField<int32_t>(4, 0);
3156 }
seed2FLATBUFFERS_FINAL_CLASS3157 int32_t seed2() const {
3158 return GetField<int32_t>(6, 0);
3159 }
typeFLATBUFFERS_FINAL_CLASS3160 DataType type() const {
3161 return static_cast<DataType>(GetField<int32_t>(8, 1));
3162 }
lowFLATBUFFERS_FINAL_CLASS3163 float low() const {
3164 return GetField<float>(10, 0.0f);
3165 }
highFLATBUFFERS_FINAL_CLASS3166 float high() const {
3167 return GetField<float>(12, 1.0f);
3168 }
VerifyFLATBUFFERS_FINAL_CLASS3169 bool Verify(flatbuffers::Verifier &verifier) const {
3170 return VerifyTableStart(verifier) &&
3171 VerifyField<int32_t>(verifier, 4) &&
3172 VerifyField<int32_t>(verifier, 6) &&
3173 VerifyField<int32_t>(verifier, 8) &&
3174 VerifyField<float>(verifier, 10) &&
3175 VerifyField<float>(verifier, 12) &&
3176 verifier.EndTable();
3177 }
3178 RandomUniformT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3179 void UnPackTo(RandomUniformT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3180 static flatbuffers::Offset<RandomUniform> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RandomUniformT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3181 };
3182
3183 struct RandomUniformBuilder {
3184 flatbuffers::FlatBufferBuilder &fbb_;
3185 flatbuffers::uoffset_t start_;
add_seedRandomUniformBuilder3186 void add_seed(int32_t seed) {
3187 fbb_.AddElement<int32_t>(4, seed, 0);
3188 }
add_seed2RandomUniformBuilder3189 void add_seed2(int32_t seed2) {
3190 fbb_.AddElement<int32_t>(6, seed2, 0);
3191 }
add_typeRandomUniformBuilder3192 void add_type(DataType type) {
3193 fbb_.AddElement<int32_t>(8, static_cast<int32_t>(type), 1);
3194 }
add_lowRandomUniformBuilder3195 void add_low(float low) {
3196 fbb_.AddElement<float>(10, low, 0.0f);
3197 }
add_highRandomUniformBuilder3198 void add_high(float high) {
3199 fbb_.AddElement<float>(12, high, 1.0f);
3200 }
RandomUniformBuilderRandomUniformBuilder3201 explicit RandomUniformBuilder(flatbuffers::FlatBufferBuilder &_fbb)
3202 : fbb_(_fbb) {
3203 start_ = fbb_.StartTable();
3204 }
3205 RandomUniformBuilder &operator=(const RandomUniformBuilder &);
FinishRandomUniformBuilder3206 flatbuffers::Offset<RandomUniform> Finish() {
3207 const auto end = fbb_.EndTable(start_);
3208 auto o = flatbuffers::Offset<RandomUniform>(end);
3209 return o;
3210 }
3211 };
3212
3213 inline flatbuffers::Offset<RandomUniform> CreateRandomUniform(
3214 flatbuffers::FlatBufferBuilder &_fbb,
3215 int32_t seed = 0,
3216 int32_t seed2 = 0,
3217 DataType type = DataType_DT_FLOAT,
3218 float low = 0.0f,
3219 float high = 1.0f) {
3220 RandomUniformBuilder builder_(_fbb);
3221 builder_.add_high(high);
3222 builder_.add_low(low);
3223 builder_.add_type(type);
3224 builder_.add_seed2(seed2);
3225 builder_.add_seed(seed);
3226 return builder_.Finish();
3227 }
3228
3229 flatbuffers::Offset<RandomUniform> CreateRandomUniform(flatbuffers::FlatBufferBuilder &_fbb, const RandomUniformT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3230
3231 struct TensorArrayT : public flatbuffers::NativeTable {
3232 typedef TensorArray TableType;
3233 bool dynamic_size;
3234 bool identical_element_shapes;
3235 std::vector<int32_t> element_shape;
3236 DataType T;
TensorArrayTTensorArrayT3237 TensorArrayT()
3238 : dynamic_size(false),
3239 identical_element_shapes(false),
3240 T(DataType_DT_FLOAT) {
3241 }
3242 };
3243
3244 struct TensorArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
3245 typedef TensorArrayT NativeTableType;
MiniReflectTypeTableFLATBUFFERS_FINAL_CLASS3246 static const flatbuffers::TypeTable *MiniReflectTypeTable() {
3247 return TensorArrayTypeTable();
3248 }
dynamic_sizeFLATBUFFERS_FINAL_CLASS3249 bool dynamic_size() const {
3250 return GetField<uint8_t>(4, 0) != 0;
3251 }
identical_element_shapesFLATBUFFERS_FINAL_CLASS3252 bool identical_element_shapes() const {
3253 return GetField<uint8_t>(6, 0) != 0;
3254 }
element_shapeFLATBUFFERS_FINAL_CLASS3255 const flatbuffers::Vector<int32_t> *element_shape() const {
3256 return GetPointer<const flatbuffers::Vector<int32_t> *>(8);
3257 }
TFLATBUFFERS_FINAL_CLASS3258 DataType T() const {
3259 return static_cast<DataType>(GetField<int32_t>(10, 1));
3260 }
VerifyFLATBUFFERS_FINAL_CLASS3261 bool Verify(flatbuffers::Verifier &verifier) const {
3262 return VerifyTableStart(verifier) &&
3263 VerifyField<uint8_t>(verifier, 4) &&
3264 VerifyField<uint8_t>(verifier, 6) &&
3265 VerifyOffset(verifier, 8) &&
3266 verifier.VerifyVector(element_shape()) &&
3267 VerifyField<int32_t>(verifier, 10) &&
3268 verifier.EndTable();
3269 }
3270 TensorArrayT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3271 void UnPackTo(TensorArrayT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
3272 static flatbuffers::Offset<TensorArray> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorArrayT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
3273 };
3274
3275 struct TensorArrayBuilder {
3276 flatbuffers::FlatBufferBuilder &fbb_;
3277 flatbuffers::uoffset_t start_;
add_dynamic_sizeTensorArrayBuilder3278 void add_dynamic_size(bool dynamic_size) {
3279 fbb_.AddElement<uint8_t>(4, static_cast<uint8_t>(dynamic_size), 0);
3280 }
add_identical_element_shapesTensorArrayBuilder3281 void add_identical_element_shapes(bool identical_element_shapes) {
3282 fbb_.AddElement<uint8_t>(6, static_cast<uint8_t>(identical_element_shapes), 0);
3283 }
add_element_shapeTensorArrayBuilder3284 void add_element_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> element_shape) {
3285 fbb_.AddOffset(8, element_shape);
3286 }
add_TTensorArrayBuilder3287