1 /* Copyright 2018 The TensorFlow Authors. All Rights Reserved. 2 3 Licensed under the Apache License, Version 2.0 (the "License"); 4 you may not use this file except in compliance with the License. 5 You may obtain a copy of the License at 6 7 http://www.apache.org/licenses/LICENSE-2.0 8 9 Unless required by applicable law or agreed to in writing, software 10 distributed under the License is distributed on an "AS IS" BASIS, 11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 See the License for the specific language governing permissions and 13 limitations under the License. 14 ==============================================================================*/ 15 // automatically generated by the FlatBuffers compiler, do not modify 16 17 18 #ifndef FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_ 19 #define FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_ 20 21 #include "flatbuffers/flatbuffers.h" 22 23 namespace tflite { 24 25 struct CustomQuantization; 26 struct CustomQuantizationT; 27 28 struct QuantizationParameters; 29 struct QuantizationParametersT; 30 31 struct Tensor; 32 struct TensorT; 33 34 struct Conv2DOptions; 35 struct Conv2DOptionsT; 36 37 struct Pool2DOptions; 38 struct Pool2DOptionsT; 39 40 struct DepthwiseConv2DOptions; 41 struct DepthwiseConv2DOptionsT; 42 43 struct ConcatEmbeddingsOptions; 44 struct ConcatEmbeddingsOptionsT; 45 46 struct LSHProjectionOptions; 47 struct LSHProjectionOptionsT; 48 49 struct SVDFOptions; 50 struct SVDFOptionsT; 51 52 struct RNNOptions; 53 struct RNNOptionsT; 54 55 struct SequenceRNNOptions; 56 struct SequenceRNNOptionsT; 57 58 struct BidirectionalSequenceRNNOptions; 59 struct BidirectionalSequenceRNNOptionsT; 60 61 struct FullyConnectedOptions; 62 struct FullyConnectedOptionsT; 63 64 struct SoftmaxOptions; 65 struct SoftmaxOptionsT; 66 67 struct ConcatenationOptions; 68 struct ConcatenationOptionsT; 69 70 struct AddOptions; 71 struct AddOptionsT; 72 73 struct MulOptions; 74 struct MulOptionsT; 75 76 struct L2NormOptions; 77 struct L2NormOptionsT; 78 79 struct LocalResponseNormalizationOptions; 80 struct LocalResponseNormalizationOptionsT; 81 82 struct LSTMOptions; 83 struct LSTMOptionsT; 84 85 struct UnidirectionalSequenceLSTMOptions; 86 struct UnidirectionalSequenceLSTMOptionsT; 87 88 struct BidirectionalSequenceLSTMOptions; 89 struct BidirectionalSequenceLSTMOptionsT; 90 91 struct ResizeBilinearOptions; 92 struct ResizeBilinearOptionsT; 93 94 struct ResizeNearestNeighborOptions; 95 struct ResizeNearestNeighborOptionsT; 96 97 struct CallOptions; 98 struct CallOptionsT; 99 100 struct PadOptions; 101 struct PadOptionsT; 102 103 struct PadV2Options; 104 struct PadV2OptionsT; 105 106 struct ReshapeOptions; 107 struct ReshapeOptionsT; 108 109 struct SpaceToBatchNDOptions; 110 struct SpaceToBatchNDOptionsT; 111 112 struct BatchToSpaceNDOptions; 113 struct BatchToSpaceNDOptionsT; 114 115 struct SkipGramOptions; 116 struct SkipGramOptionsT; 117 118 struct SpaceToDepthOptions; 119 struct SpaceToDepthOptionsT; 120 121 struct SubOptions; 122 struct SubOptionsT; 123 124 struct DivOptions; 125 struct DivOptionsT; 126 127 struct TopKV2Options; 128 struct TopKV2OptionsT; 129 130 struct EmbeddingLookupSparseOptions; 131 struct EmbeddingLookupSparseOptionsT; 132 133 struct GatherOptions; 134 struct GatherOptionsT; 135 136 struct TransposeOptions; 137 struct TransposeOptionsT; 138 139 struct ExpOptions; 140 struct ExpOptionsT; 141 142 struct CosOptions; 143 struct CosOptionsT; 144 145 struct ReducerOptions; 146 struct ReducerOptionsT; 147 148 struct SqueezeOptions; 149 struct SqueezeOptionsT; 150 151 struct SplitOptions; 152 struct SplitOptionsT; 153 154 struct SplitVOptions; 155 struct SplitVOptionsT; 156 157 struct StridedSliceOptions; 158 struct StridedSliceOptionsT; 159 160 struct LogSoftmaxOptions; 161 struct LogSoftmaxOptionsT; 162 163 struct CastOptions; 164 struct CastOptionsT; 165 166 struct DequantizeOptions; 167 struct DequantizeOptionsT; 168 169 struct MaximumMinimumOptions; 170 struct MaximumMinimumOptionsT; 171 172 struct TileOptions; 173 struct TileOptionsT; 174 175 struct ArgMaxOptions; 176 struct ArgMaxOptionsT; 177 178 struct ArgMinOptions; 179 struct ArgMinOptionsT; 180 181 struct GreaterOptions; 182 struct GreaterOptionsT; 183 184 struct GreaterEqualOptions; 185 struct GreaterEqualOptionsT; 186 187 struct LessOptions; 188 struct LessOptionsT; 189 190 struct LessEqualOptions; 191 struct LessEqualOptionsT; 192 193 struct NegOptions; 194 struct NegOptionsT; 195 196 struct SelectOptions; 197 struct SelectOptionsT; 198 199 struct SliceOptions; 200 struct SliceOptionsT; 201 202 struct TransposeConvOptions; 203 struct TransposeConvOptionsT; 204 205 struct ExpandDimsOptions; 206 struct ExpandDimsOptionsT; 207 208 struct SparseToDenseOptions; 209 struct SparseToDenseOptionsT; 210 211 struct EqualOptions; 212 struct EqualOptionsT; 213 214 struct NotEqualOptions; 215 struct NotEqualOptionsT; 216 217 struct ShapeOptions; 218 struct ShapeOptionsT; 219 220 struct RankOptions; 221 struct RankOptionsT; 222 223 struct PowOptions; 224 struct PowOptionsT; 225 226 struct FakeQuantOptions; 227 struct FakeQuantOptionsT; 228 229 struct PackOptions; 230 struct PackOptionsT; 231 232 struct LogicalOrOptions; 233 struct LogicalOrOptionsT; 234 235 struct OneHotOptions; 236 struct OneHotOptionsT; 237 238 struct AbsOptions; 239 struct AbsOptionsT; 240 241 struct LogicalAndOptions; 242 struct LogicalAndOptionsT; 243 244 struct LogicalNotOptions; 245 struct LogicalNotOptionsT; 246 247 struct UnpackOptions; 248 struct UnpackOptionsT; 249 250 struct FloorDivOptions; 251 struct FloorDivOptionsT; 252 253 struct SquareOptions; 254 struct SquareOptionsT; 255 256 struct ZerosLikeOptions; 257 struct ZerosLikeOptionsT; 258 259 struct FillOptions; 260 struct FillOptionsT; 261 262 struct FloorModOptions; 263 struct FloorModOptionsT; 264 265 struct RangeOptions; 266 struct RangeOptionsT; 267 268 struct LeakyReluOptions; 269 struct LeakyReluOptionsT; 270 271 struct SquaredDifferenceOptions; 272 struct SquaredDifferenceOptionsT; 273 274 struct MirrorPadOptions; 275 struct MirrorPadOptionsT; 276 277 struct UniqueOptions; 278 struct UniqueOptionsT; 279 280 struct ReverseV2Options; 281 struct ReverseV2OptionsT; 282 283 struct AddNOptions; 284 struct AddNOptionsT; 285 286 struct GatherNdOptions; 287 struct GatherNdOptionsT; 288 289 struct WhereOptions; 290 struct WhereOptionsT; 291 292 struct ReverseSequenceOptions; 293 struct ReverseSequenceOptionsT; 294 295 struct OperatorCode; 296 struct OperatorCodeT; 297 298 struct Operator; 299 struct OperatorT; 300 301 struct SubGraph; 302 struct SubGraphT; 303 304 struct Buffer; 305 struct BufferT; 306 307 struct Model; 308 struct ModelT; 309 310 enum TensorType { 311 TensorType_FLOAT32 = 0, 312 TensorType_FLOAT16 = 1, 313 TensorType_INT32 = 2, 314 TensorType_UINT8 = 3, 315 TensorType_INT64 = 4, 316 TensorType_STRING = 5, 317 TensorType_BOOL = 6, 318 TensorType_INT16 = 7, 319 TensorType_COMPLEX64 = 8, 320 TensorType_INT8 = 9, 321 TensorType_MIN = TensorType_FLOAT32, 322 TensorType_MAX = TensorType_INT8 323 }; 324 325 inline const TensorType (&EnumValuesTensorType())[10] { 326 static const TensorType values[] = { 327 TensorType_FLOAT32, 328 TensorType_FLOAT16, 329 TensorType_INT32, 330 TensorType_UINT8, 331 TensorType_INT64, 332 TensorType_STRING, 333 TensorType_BOOL, 334 TensorType_INT16, 335 TensorType_COMPLEX64, 336 TensorType_INT8 337 }; 338 return values; 339 } 340 341 inline const char * const *EnumNamesTensorType() { 342 static const char * const names[] = { 343 "FLOAT32", 344 "FLOAT16", 345 "INT32", 346 "UINT8", 347 "INT64", 348 "STRING", 349 "BOOL", 350 "INT16", 351 "COMPLEX64", 352 "INT8", 353 nullptr 354 }; 355 return names; 356 } 357 358 inline const char *EnumNameTensorType(TensorType e) { 359 const size_t index = static_cast<int>(e); 360 return EnumNamesTensorType()[index]; 361 } 362 363 enum QuantizationDetails { 364 QuantizationDetails_NONE = 0, 365 QuantizationDetails_CustomQuantization = 1, 366 QuantizationDetails_MIN = QuantizationDetails_NONE, 367 QuantizationDetails_MAX = QuantizationDetails_CustomQuantization 368 }; 369 370 inline const QuantizationDetails (&EnumValuesQuantizationDetails())[2] { 371 static const QuantizationDetails values[] = { 372 QuantizationDetails_NONE, 373 QuantizationDetails_CustomQuantization 374 }; 375 return values; 376 } 377 378 inline const char * const *EnumNamesQuantizationDetails() { 379 static const char * const names[] = { 380 "NONE", 381 "CustomQuantization", 382 nullptr 383 }; 384 return names; 385 } 386 387 inline const char *EnumNameQuantizationDetails(QuantizationDetails e) { 388 const size_t index = static_cast<int>(e); 389 return EnumNamesQuantizationDetails()[index]; 390 } 391 392 template<typename T> struct QuantizationDetailsTraits { 393 static const QuantizationDetails enum_value = QuantizationDetails_NONE; 394 }; 395 396 template<> struct QuantizationDetailsTraits<CustomQuantization> { 397 static const QuantizationDetails enum_value = QuantizationDetails_CustomQuantization; 398 }; 399 400 struct QuantizationDetailsUnion { 401 QuantizationDetails type; 402 void *value; 403 404 QuantizationDetailsUnion() : type(QuantizationDetails_NONE), value(nullptr) {} 405 QuantizationDetailsUnion(QuantizationDetailsUnion&& u) FLATBUFFERS_NOEXCEPT : 406 type(QuantizationDetails_NONE), value(nullptr) 407 { std::swap(type, u.type); std::swap(value, u.value); } 408 QuantizationDetailsUnion(const QuantizationDetailsUnion &) FLATBUFFERS_NOEXCEPT; 409 QuantizationDetailsUnion &operator=(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT 410 { QuantizationDetailsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } 411 QuantizationDetailsUnion &operator=(QuantizationDetailsUnion &&u) FLATBUFFERS_NOEXCEPT 412 { std::swap(type, u.type); std::swap(value, u.value); return *this; } 413 ~QuantizationDetailsUnion() { Reset(); } 414 415 void Reset(); 416 417 #ifndef FLATBUFFERS_CPP98_STL 418 template <typename T> 419 void Set(T&& val) { 420 Reset(); 421 type = QuantizationDetailsTraits<typename T::TableType>::enum_value; 422 if (type != QuantizationDetails_NONE) { 423 value = new T(std::forward<T>(val)); 424 } 425 } 426 #endif // FLATBUFFERS_CPP98_STL 427 428 static void *UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver); 429 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 430 431 CustomQuantizationT *AsCustomQuantization() { 432 return type == QuantizationDetails_CustomQuantization ? 433 reinterpret_cast<CustomQuantizationT *>(value) : nullptr; 434 } 435 const CustomQuantizationT *AsCustomQuantization() const { 436 return type == QuantizationDetails_CustomQuantization ? 437 reinterpret_cast<const CustomQuantizationT *>(value) : nullptr; 438 } 439 }; 440 441 bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type); 442 bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 443 444 enum BuiltinOperator { 445 BuiltinOperator_ADD = 0, 446 BuiltinOperator_AVERAGE_POOL_2D = 1, 447 BuiltinOperator_CONCATENATION = 2, 448 BuiltinOperator_CONV_2D = 3, 449 BuiltinOperator_DEPTHWISE_CONV_2D = 4, 450 BuiltinOperator_DEQUANTIZE = 6, 451 BuiltinOperator_EMBEDDING_LOOKUP = 7, 452 BuiltinOperator_FLOOR = 8, 453 BuiltinOperator_FULLY_CONNECTED = 9, 454 BuiltinOperator_HASHTABLE_LOOKUP = 10, 455 BuiltinOperator_L2_NORMALIZATION = 11, 456 BuiltinOperator_L2_POOL_2D = 12, 457 BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION = 13, 458 BuiltinOperator_LOGISTIC = 14, 459 BuiltinOperator_LSH_PROJECTION = 15, 460 BuiltinOperator_LSTM = 16, 461 BuiltinOperator_MAX_POOL_2D = 17, 462 BuiltinOperator_MUL = 18, 463 BuiltinOperator_RELU = 19, 464 BuiltinOperator_RELU_N1_TO_1 = 20, 465 BuiltinOperator_RELU6 = 21, 466 BuiltinOperator_RESHAPE = 22, 467 BuiltinOperator_RESIZE_BILINEAR = 23, 468 BuiltinOperator_RNN = 24, 469 BuiltinOperator_SOFTMAX = 25, 470 BuiltinOperator_SPACE_TO_DEPTH = 26, 471 BuiltinOperator_SVDF = 27, 472 BuiltinOperator_TANH = 28, 473 BuiltinOperator_CONCAT_EMBEDDINGS = 29, 474 BuiltinOperator_SKIP_GRAM = 30, 475 BuiltinOperator_CALL = 31, 476 BuiltinOperator_CUSTOM = 32, 477 BuiltinOperator_EMBEDDING_LOOKUP_SPARSE = 33, 478 BuiltinOperator_PAD = 34, 479 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN = 35, 480 BuiltinOperator_GATHER = 36, 481 BuiltinOperator_BATCH_TO_SPACE_ND = 37, 482 BuiltinOperator_SPACE_TO_BATCH_ND = 38, 483 BuiltinOperator_TRANSPOSE = 39, 484 BuiltinOperator_MEAN = 40, 485 BuiltinOperator_SUB = 41, 486 BuiltinOperator_DIV = 42, 487 BuiltinOperator_SQUEEZE = 43, 488 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM = 44, 489 BuiltinOperator_STRIDED_SLICE = 45, 490 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN = 46, 491 BuiltinOperator_EXP = 47, 492 BuiltinOperator_TOPK_V2 = 48, 493 BuiltinOperator_SPLIT = 49, 494 BuiltinOperator_LOG_SOFTMAX = 50, 495 BuiltinOperator_DELEGATE = 51, 496 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM = 52, 497 BuiltinOperator_CAST = 53, 498 BuiltinOperator_PRELU = 54, 499 BuiltinOperator_MAXIMUM = 55, 500 BuiltinOperator_ARG_MAX = 56, 501 BuiltinOperator_MINIMUM = 57, 502 BuiltinOperator_LESS = 58, 503 BuiltinOperator_NEG = 59, 504 BuiltinOperator_PADV2 = 60, 505 BuiltinOperator_GREATER = 61, 506 BuiltinOperator_GREATER_EQUAL = 62, 507 BuiltinOperator_LESS_EQUAL = 63, 508 BuiltinOperator_SELECT = 64, 509 BuiltinOperator_SLICE = 65, 510 BuiltinOperator_SIN = 66, 511 BuiltinOperator_TRANSPOSE_CONV = 67, 512 BuiltinOperator_SPARSE_TO_DENSE = 68, 513 BuiltinOperator_TILE = 69, 514 BuiltinOperator_EXPAND_DIMS = 70, 515 BuiltinOperator_EQUAL = 71, 516 BuiltinOperator_NOT_EQUAL = 72, 517 BuiltinOperator_LOG = 73, 518 BuiltinOperator_SUM = 74, 519 BuiltinOperator_SQRT = 75, 520 BuiltinOperator_RSQRT = 76, 521 BuiltinOperator_SHAPE = 77, 522 BuiltinOperator_POW = 78, 523 BuiltinOperator_ARG_MIN = 79, 524 BuiltinOperator_FAKE_QUANT = 80, 525 BuiltinOperator_REDUCE_PROD = 81, 526 BuiltinOperator_REDUCE_MAX = 82, 527 BuiltinOperator_PACK = 83, 528 BuiltinOperator_LOGICAL_OR = 84, 529 BuiltinOperator_ONE_HOT = 85, 530 BuiltinOperator_LOGICAL_AND = 86, 531 BuiltinOperator_LOGICAL_NOT = 87, 532 BuiltinOperator_UNPACK = 88, 533 BuiltinOperator_REDUCE_MIN = 89, 534 BuiltinOperator_FLOOR_DIV = 90, 535 BuiltinOperator_REDUCE_ANY = 91, 536 BuiltinOperator_SQUARE = 92, 537 BuiltinOperator_ZEROS_LIKE = 93, 538 BuiltinOperator_FILL = 94, 539 BuiltinOperator_FLOOR_MOD = 95, 540 BuiltinOperator_RANGE = 96, 541 BuiltinOperator_RESIZE_NEAREST_NEIGHBOR = 97, 542 BuiltinOperator_LEAKY_RELU = 98, 543 BuiltinOperator_SQUARED_DIFFERENCE = 99, 544 BuiltinOperator_MIRROR_PAD = 100, 545 BuiltinOperator_ABS = 101, 546 BuiltinOperator_SPLIT_V = 102, 547 BuiltinOperator_UNIQUE = 103, 548 BuiltinOperator_CEIL = 104, 549 BuiltinOperator_REVERSE_V2 = 105, 550 BuiltinOperator_ADD_N = 106, 551 BuiltinOperator_GATHER_ND = 107, 552 BuiltinOperator_COS = 108, 553 BuiltinOperator_WHERE = 109, 554 BuiltinOperator_RANK = 110, 555 BuiltinOperator_ELU = 111, 556 BuiltinOperator_REVERSE_SEQUENCE = 112, 557 BuiltinOperator_MIN = BuiltinOperator_ADD, 558 BuiltinOperator_MAX = BuiltinOperator_REVERSE_SEQUENCE 559 }; 560 561 inline const BuiltinOperator (&EnumValuesBuiltinOperator())[112] { 562 static const BuiltinOperator values[] = { 563 BuiltinOperator_ADD, 564 BuiltinOperator_AVERAGE_POOL_2D, 565 BuiltinOperator_CONCATENATION, 566 BuiltinOperator_CONV_2D, 567 BuiltinOperator_DEPTHWISE_CONV_2D, 568 BuiltinOperator_DEQUANTIZE, 569 BuiltinOperator_EMBEDDING_LOOKUP, 570 BuiltinOperator_FLOOR, 571 BuiltinOperator_FULLY_CONNECTED, 572 BuiltinOperator_HASHTABLE_LOOKUP, 573 BuiltinOperator_L2_NORMALIZATION, 574 BuiltinOperator_L2_POOL_2D, 575 BuiltinOperator_LOCAL_RESPONSE_NORMALIZATION, 576 BuiltinOperator_LOGISTIC, 577 BuiltinOperator_LSH_PROJECTION, 578 BuiltinOperator_LSTM, 579 BuiltinOperator_MAX_POOL_2D, 580 BuiltinOperator_MUL, 581 BuiltinOperator_RELU, 582 BuiltinOperator_RELU_N1_TO_1, 583 BuiltinOperator_RELU6, 584 BuiltinOperator_RESHAPE, 585 BuiltinOperator_RESIZE_BILINEAR, 586 BuiltinOperator_RNN, 587 BuiltinOperator_SOFTMAX, 588 BuiltinOperator_SPACE_TO_DEPTH, 589 BuiltinOperator_SVDF, 590 BuiltinOperator_TANH, 591 BuiltinOperator_CONCAT_EMBEDDINGS, 592 BuiltinOperator_SKIP_GRAM, 593 BuiltinOperator_CALL, 594 BuiltinOperator_CUSTOM, 595 BuiltinOperator_EMBEDDING_LOOKUP_SPARSE, 596 BuiltinOperator_PAD, 597 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_RNN, 598 BuiltinOperator_GATHER, 599 BuiltinOperator_BATCH_TO_SPACE_ND, 600 BuiltinOperator_SPACE_TO_BATCH_ND, 601 BuiltinOperator_TRANSPOSE, 602 BuiltinOperator_MEAN, 603 BuiltinOperator_SUB, 604 BuiltinOperator_DIV, 605 BuiltinOperator_SQUEEZE, 606 BuiltinOperator_UNIDIRECTIONAL_SEQUENCE_LSTM, 607 BuiltinOperator_STRIDED_SLICE, 608 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_RNN, 609 BuiltinOperator_EXP, 610 BuiltinOperator_TOPK_V2, 611 BuiltinOperator_SPLIT, 612 BuiltinOperator_LOG_SOFTMAX, 613 BuiltinOperator_DELEGATE, 614 BuiltinOperator_BIDIRECTIONAL_SEQUENCE_LSTM, 615 BuiltinOperator_CAST, 616 BuiltinOperator_PRELU, 617 BuiltinOperator_MAXIMUM, 618 BuiltinOperator_ARG_MAX, 619 BuiltinOperator_MINIMUM, 620 BuiltinOperator_LESS, 621 BuiltinOperator_NEG, 622 BuiltinOperator_PADV2, 623 BuiltinOperator_GREATER, 624 BuiltinOperator_GREATER_EQUAL, 625 BuiltinOperator_LESS_EQUAL, 626 BuiltinOperator_SELECT, 627 BuiltinOperator_SLICE, 628 BuiltinOperator_SIN, 629 BuiltinOperator_TRANSPOSE_CONV, 630 BuiltinOperator_SPARSE_TO_DENSE, 631 BuiltinOperator_TILE, 632 BuiltinOperator_EXPAND_DIMS, 633 BuiltinOperator_EQUAL, 634 BuiltinOperator_NOT_EQUAL, 635 BuiltinOperator_LOG, 636 BuiltinOperator_SUM, 637 BuiltinOperator_SQRT, 638 BuiltinOperator_RSQRT, 639 BuiltinOperator_SHAPE, 640 BuiltinOperator_POW, 641 BuiltinOperator_ARG_MIN, 642 BuiltinOperator_FAKE_QUANT, 643 BuiltinOperator_REDUCE_PROD, 644 BuiltinOperator_REDUCE_MAX, 645 BuiltinOperator_PACK, 646 BuiltinOperator_LOGICAL_OR, 647 BuiltinOperator_ONE_HOT, 648 BuiltinOperator_LOGICAL_AND, 649 BuiltinOperator_LOGICAL_NOT, 650 BuiltinOperator_UNPACK, 651 BuiltinOperator_REDUCE_MIN, 652 BuiltinOperator_FLOOR_DIV, 653 BuiltinOperator_REDUCE_ANY, 654 BuiltinOperator_SQUARE, 655 BuiltinOperator_ZEROS_LIKE, 656 BuiltinOperator_FILL, 657 BuiltinOperator_FLOOR_MOD, 658 BuiltinOperator_RANGE, 659 BuiltinOperator_RESIZE_NEAREST_NEIGHBOR, 660 BuiltinOperator_LEAKY_RELU, 661 BuiltinOperator_SQUARED_DIFFERENCE, 662 BuiltinOperator_MIRROR_PAD, 663 BuiltinOperator_ABS, 664 BuiltinOperator_SPLIT_V, 665 BuiltinOperator_UNIQUE, 666 BuiltinOperator_CEIL, 667 BuiltinOperator_REVERSE_V2, 668 BuiltinOperator_ADD_N, 669 BuiltinOperator_GATHER_ND, 670 BuiltinOperator_COS, 671 BuiltinOperator_WHERE, 672 BuiltinOperator_RANK, 673 BuiltinOperator_ELU, 674 BuiltinOperator_REVERSE_SEQUENCE 675 }; 676 return values; 677 } 678 679 inline const char * const *EnumNamesBuiltinOperator() { 680 static const char * const names[] = { 681 "ADD", 682 "AVERAGE_POOL_2D", 683 "CONCATENATION", 684 "CONV_2D", 685 "DEPTHWISE_CONV_2D", 686 "", 687 "DEQUANTIZE", 688 "EMBEDDING_LOOKUP", 689 "FLOOR", 690 "FULLY_CONNECTED", 691 "HASHTABLE_LOOKUP", 692 "L2_NORMALIZATION", 693 "L2_POOL_2D", 694 "LOCAL_RESPONSE_NORMALIZATION", 695 "LOGISTIC", 696 "LSH_PROJECTION", 697 "LSTM", 698 "MAX_POOL_2D", 699 "MUL", 700 "RELU", 701 "RELU_N1_TO_1", 702 "RELU6", 703 "RESHAPE", 704 "RESIZE_BILINEAR", 705 "RNN", 706 "SOFTMAX", 707 "SPACE_TO_DEPTH", 708 "SVDF", 709 "TANH", 710 "CONCAT_EMBEDDINGS", 711 "SKIP_GRAM", 712 "CALL", 713 "CUSTOM", 714 "EMBEDDING_LOOKUP_SPARSE", 715 "PAD", 716 "UNIDIRECTIONAL_SEQUENCE_RNN", 717 "GATHER", 718 "BATCH_TO_SPACE_ND", 719 "SPACE_TO_BATCH_ND", 720 "TRANSPOSE", 721 "MEAN", 722 "SUB", 723 "DIV", 724 "SQUEEZE", 725 "UNIDIRECTIONAL_SEQUENCE_LSTM", 726 "STRIDED_SLICE", 727 "BIDIRECTIONAL_SEQUENCE_RNN", 728 "EXP", 729 "TOPK_V2", 730 "SPLIT", 731 "LOG_SOFTMAX", 732 "DELEGATE", 733 "BIDIRECTIONAL_SEQUENCE_LSTM", 734 "CAST", 735 "PRELU", 736 "MAXIMUM", 737 "ARG_MAX", 738 "MINIMUM", 739 "LESS", 740 "NEG", 741 "PADV2", 742 "GREATER", 743 "GREATER_EQUAL", 744 "LESS_EQUAL", 745 "SELECT", 746 "SLICE", 747 "SIN", 748 "TRANSPOSE_CONV", 749 "SPARSE_TO_DENSE", 750 "TILE", 751 "EXPAND_DIMS", 752 "EQUAL", 753 "NOT_EQUAL", 754 "LOG", 755 "SUM", 756 "SQRT", 757 "RSQRT", 758 "SHAPE", 759 "POW", 760 "ARG_MIN", 761 "FAKE_QUANT", 762 "REDUCE_PROD", 763 "REDUCE_MAX", 764 "PACK", 765 "LOGICAL_OR", 766 "ONE_HOT", 767 "LOGICAL_AND", 768 "LOGICAL_NOT", 769 "UNPACK", 770 "REDUCE_MIN", 771 "FLOOR_DIV", 772 "REDUCE_ANY", 773 "SQUARE", 774 "ZEROS_LIKE", 775 "FILL", 776 "FLOOR_MOD", 777 "RANGE", 778 "RESIZE_NEAREST_NEIGHBOR", 779 "LEAKY_RELU", 780 "SQUARED_DIFFERENCE", 781 "MIRROR_PAD", 782 "ABS", 783 "SPLIT_V", 784 "UNIQUE", 785 "CEIL", 786 "REVERSE_V2", 787 "ADD_N", 788 "GATHER_ND", 789 "COS", 790 "WHERE", 791 "RANK", 792 "ELU", 793 "REVERSE_SEQUENCE", 794 nullptr 795 }; 796 return names; 797 } 798 799 inline const char *EnumNameBuiltinOperator(BuiltinOperator e) { 800 const size_t index = static_cast<int>(e); 801 return EnumNamesBuiltinOperator()[index]; 802 } 803 804 enum BuiltinOptions { 805 BuiltinOptions_NONE = 0, 806 BuiltinOptions_Conv2DOptions = 1, 807 BuiltinOptions_DepthwiseConv2DOptions = 2, 808 BuiltinOptions_ConcatEmbeddingsOptions = 3, 809 BuiltinOptions_LSHProjectionOptions = 4, 810 BuiltinOptions_Pool2DOptions = 5, 811 BuiltinOptions_SVDFOptions = 6, 812 BuiltinOptions_RNNOptions = 7, 813 BuiltinOptions_FullyConnectedOptions = 8, 814 BuiltinOptions_SoftmaxOptions = 9, 815 BuiltinOptions_ConcatenationOptions = 10, 816 BuiltinOptions_AddOptions = 11, 817 BuiltinOptions_L2NormOptions = 12, 818 BuiltinOptions_LocalResponseNormalizationOptions = 13, 819 BuiltinOptions_LSTMOptions = 14, 820 BuiltinOptions_ResizeBilinearOptions = 15, 821 BuiltinOptions_CallOptions = 16, 822 BuiltinOptions_ReshapeOptions = 17, 823 BuiltinOptions_SkipGramOptions = 18, 824 BuiltinOptions_SpaceToDepthOptions = 19, 825 BuiltinOptions_EmbeddingLookupSparseOptions = 20, 826 BuiltinOptions_MulOptions = 21, 827 BuiltinOptions_PadOptions = 22, 828 BuiltinOptions_GatherOptions = 23, 829 BuiltinOptions_BatchToSpaceNDOptions = 24, 830 BuiltinOptions_SpaceToBatchNDOptions = 25, 831 BuiltinOptions_TransposeOptions = 26, 832 BuiltinOptions_ReducerOptions = 27, 833 BuiltinOptions_SubOptions = 28, 834 BuiltinOptions_DivOptions = 29, 835 BuiltinOptions_SqueezeOptions = 30, 836 BuiltinOptions_SequenceRNNOptions = 31, 837 BuiltinOptions_StridedSliceOptions = 32, 838 BuiltinOptions_ExpOptions = 33, 839 BuiltinOptions_TopKV2Options = 34, 840 BuiltinOptions_SplitOptions = 35, 841 BuiltinOptions_LogSoftmaxOptions = 36, 842 BuiltinOptions_CastOptions = 37, 843 BuiltinOptions_DequantizeOptions = 38, 844 BuiltinOptions_MaximumMinimumOptions = 39, 845 BuiltinOptions_ArgMaxOptions = 40, 846 BuiltinOptions_LessOptions = 41, 847 BuiltinOptions_NegOptions = 42, 848 BuiltinOptions_PadV2Options = 43, 849 BuiltinOptions_GreaterOptions = 44, 850 BuiltinOptions_GreaterEqualOptions = 45, 851 BuiltinOptions_LessEqualOptions = 46, 852 BuiltinOptions_SelectOptions = 47, 853 BuiltinOptions_SliceOptions = 48, 854 BuiltinOptions_TransposeConvOptions = 49, 855 BuiltinOptions_SparseToDenseOptions = 50, 856 BuiltinOptions_TileOptions = 51, 857 BuiltinOptions_ExpandDimsOptions = 52, 858 BuiltinOptions_EqualOptions = 53, 859 BuiltinOptions_NotEqualOptions = 54, 860 BuiltinOptions_ShapeOptions = 55, 861 BuiltinOptions_PowOptions = 56, 862 BuiltinOptions_ArgMinOptions = 57, 863 BuiltinOptions_FakeQuantOptions = 58, 864 BuiltinOptions_PackOptions = 59, 865 BuiltinOptions_LogicalOrOptions = 60, 866 BuiltinOptions_OneHotOptions = 61, 867 BuiltinOptions_LogicalAndOptions = 62, 868 BuiltinOptions_LogicalNotOptions = 63, 869 BuiltinOptions_UnpackOptions = 64, 870 BuiltinOptions_FloorDivOptions = 65, 871 BuiltinOptions_SquareOptions = 66, 872 BuiltinOptions_ZerosLikeOptions = 67, 873 BuiltinOptions_FillOptions = 68, 874 BuiltinOptions_BidirectionalSequenceLSTMOptions = 69, 875 BuiltinOptions_BidirectionalSequenceRNNOptions = 70, 876 BuiltinOptions_UnidirectionalSequenceLSTMOptions = 71, 877 BuiltinOptions_FloorModOptions = 72, 878 BuiltinOptions_RangeOptions = 73, 879 BuiltinOptions_ResizeNearestNeighborOptions = 74, 880 BuiltinOptions_LeakyReluOptions = 75, 881 BuiltinOptions_SquaredDifferenceOptions = 76, 882 BuiltinOptions_MirrorPadOptions = 77, 883 BuiltinOptions_AbsOptions = 78, 884 BuiltinOptions_SplitVOptions = 79, 885 BuiltinOptions_UniqueOptions = 80, 886 BuiltinOptions_ReverseV2Options = 81, 887 BuiltinOptions_AddNOptions = 82, 888 BuiltinOptions_GatherNdOptions = 83, 889 BuiltinOptions_CosOptions = 84, 890 BuiltinOptions_WhereOptions = 85, 891 BuiltinOptions_RankOptions = 86, 892 BuiltinOptions_ReverseSequenceOptions = 87, 893 BuiltinOptions_MIN = BuiltinOptions_NONE, 894 BuiltinOptions_MAX = BuiltinOptions_ReverseSequenceOptions 895 }; 896 897 inline const BuiltinOptions (&EnumValuesBuiltinOptions())[88] { 898 static const BuiltinOptions values[] = { 899 BuiltinOptions_NONE, 900 BuiltinOptions_Conv2DOptions, 901 BuiltinOptions_DepthwiseConv2DOptions, 902 BuiltinOptions_ConcatEmbeddingsOptions, 903 BuiltinOptions_LSHProjectionOptions, 904 BuiltinOptions_Pool2DOptions, 905 BuiltinOptions_SVDFOptions, 906 BuiltinOptions_RNNOptions, 907 BuiltinOptions_FullyConnectedOptions, 908 BuiltinOptions_SoftmaxOptions, 909 BuiltinOptions_ConcatenationOptions, 910 BuiltinOptions_AddOptions, 911 BuiltinOptions_L2NormOptions, 912 BuiltinOptions_LocalResponseNormalizationOptions, 913 BuiltinOptions_LSTMOptions, 914 BuiltinOptions_ResizeBilinearOptions, 915 BuiltinOptions_CallOptions, 916 BuiltinOptions_ReshapeOptions, 917 BuiltinOptions_SkipGramOptions, 918 BuiltinOptions_SpaceToDepthOptions, 919 BuiltinOptions_EmbeddingLookupSparseOptions, 920 BuiltinOptions_MulOptions, 921 BuiltinOptions_PadOptions, 922 BuiltinOptions_GatherOptions, 923 BuiltinOptions_BatchToSpaceNDOptions, 924 BuiltinOptions_SpaceToBatchNDOptions, 925 BuiltinOptions_TransposeOptions, 926 BuiltinOptions_ReducerOptions, 927 BuiltinOptions_SubOptions, 928 BuiltinOptions_DivOptions, 929 BuiltinOptions_SqueezeOptions, 930 BuiltinOptions_SequenceRNNOptions, 931 BuiltinOptions_StridedSliceOptions, 932 BuiltinOptions_ExpOptions, 933 BuiltinOptions_TopKV2Options, 934 BuiltinOptions_SplitOptions, 935 BuiltinOptions_LogSoftmaxOptions, 936 BuiltinOptions_CastOptions, 937 BuiltinOptions_DequantizeOptions, 938 BuiltinOptions_MaximumMinimumOptions, 939 BuiltinOptions_ArgMaxOptions, 940 BuiltinOptions_LessOptions, 941 BuiltinOptions_NegOptions, 942 BuiltinOptions_PadV2Options, 943 BuiltinOptions_GreaterOptions, 944 BuiltinOptions_GreaterEqualOptions, 945 BuiltinOptions_LessEqualOptions, 946 BuiltinOptions_SelectOptions, 947 BuiltinOptions_SliceOptions, 948 BuiltinOptions_TransposeConvOptions, 949 BuiltinOptions_SparseToDenseOptions, 950 BuiltinOptions_TileOptions, 951 BuiltinOptions_ExpandDimsOptions, 952 BuiltinOptions_EqualOptions, 953 BuiltinOptions_NotEqualOptions, 954 BuiltinOptions_ShapeOptions, 955 BuiltinOptions_PowOptions, 956 BuiltinOptions_ArgMinOptions, 957 BuiltinOptions_FakeQuantOptions, 958 BuiltinOptions_PackOptions, 959 BuiltinOptions_LogicalOrOptions, 960 BuiltinOptions_OneHotOptions, 961 BuiltinOptions_LogicalAndOptions, 962 BuiltinOptions_LogicalNotOptions, 963 BuiltinOptions_UnpackOptions, 964 BuiltinOptions_FloorDivOptions, 965 BuiltinOptions_SquareOptions, 966 BuiltinOptions_ZerosLikeOptions, 967 BuiltinOptions_FillOptions, 968 BuiltinOptions_BidirectionalSequenceLSTMOptions, 969 BuiltinOptions_BidirectionalSequenceRNNOptions, 970 BuiltinOptions_UnidirectionalSequenceLSTMOptions, 971 BuiltinOptions_FloorModOptions, 972 BuiltinOptions_RangeOptions, 973 BuiltinOptions_ResizeNearestNeighborOptions, 974 BuiltinOptions_LeakyReluOptions, 975 BuiltinOptions_SquaredDifferenceOptions, 976 BuiltinOptions_MirrorPadOptions, 977 BuiltinOptions_AbsOptions, 978 BuiltinOptions_SplitVOptions, 979 BuiltinOptions_UniqueOptions, 980 BuiltinOptions_ReverseV2Options, 981 BuiltinOptions_AddNOptions, 982 BuiltinOptions_GatherNdOptions, 983 BuiltinOptions_CosOptions, 984 BuiltinOptions_WhereOptions, 985 BuiltinOptions_RankOptions, 986 BuiltinOptions_ReverseSequenceOptions 987 }; 988 return values; 989 } 990 991 inline const char * const *EnumNamesBuiltinOptions() { 992 static const char * const names[] = { 993 "NONE", 994 "Conv2DOptions", 995 "DepthwiseConv2DOptions", 996 "ConcatEmbeddingsOptions", 997 "LSHProjectionOptions", 998 "Pool2DOptions", 999 "SVDFOptions", 1000 "RNNOptions", 1001 "FullyConnectedOptions", 1002 "SoftmaxOptions", 1003 "ConcatenationOptions", 1004 "AddOptions", 1005 "L2NormOptions", 1006 "LocalResponseNormalizationOptions", 1007 "LSTMOptions", 1008 "ResizeBilinearOptions", 1009 "CallOptions", 1010 "ReshapeOptions", 1011 "SkipGramOptions", 1012 "SpaceToDepthOptions", 1013 "EmbeddingLookupSparseOptions", 1014 "MulOptions", 1015 "PadOptions", 1016 "GatherOptions", 1017 "BatchToSpaceNDOptions", 1018 "SpaceToBatchNDOptions", 1019 "TransposeOptions", 1020 "ReducerOptions", 1021 "SubOptions", 1022 "DivOptions", 1023 "SqueezeOptions", 1024 "SequenceRNNOptions", 1025 "StridedSliceOptions", 1026 "ExpOptions", 1027 "TopKV2Options", 1028 "SplitOptions", 1029 "LogSoftmaxOptions", 1030 "CastOptions", 1031 "DequantizeOptions", 1032 "MaximumMinimumOptions", 1033 "ArgMaxOptions", 1034 "LessOptions", 1035 "NegOptions", 1036 "PadV2Options", 1037 "GreaterOptions", 1038 "GreaterEqualOptions", 1039 "LessEqualOptions", 1040 "SelectOptions", 1041 "SliceOptions", 1042 "TransposeConvOptions", 1043 "SparseToDenseOptions", 1044 "TileOptions", 1045 "ExpandDimsOptions", 1046 "EqualOptions", 1047 "NotEqualOptions", 1048 "ShapeOptions", 1049 "PowOptions", 1050 "ArgMinOptions", 1051 "FakeQuantOptions", 1052 "PackOptions", 1053 "LogicalOrOptions", 1054 "OneHotOptions", 1055 "LogicalAndOptions", 1056 "LogicalNotOptions", 1057 "UnpackOptions", 1058 "FloorDivOptions", 1059 "SquareOptions", 1060 "ZerosLikeOptions", 1061 "FillOptions", 1062 "BidirectionalSequenceLSTMOptions", 1063 "BidirectionalSequenceRNNOptions", 1064 "UnidirectionalSequenceLSTMOptions", 1065 "FloorModOptions", 1066 "RangeOptions", 1067 "ResizeNearestNeighborOptions", 1068 "LeakyReluOptions", 1069 "SquaredDifferenceOptions", 1070 "MirrorPadOptions", 1071 "AbsOptions", 1072 "SplitVOptions", 1073 "UniqueOptions", 1074 "ReverseV2Options", 1075 "AddNOptions", 1076 "GatherNdOptions", 1077 "CosOptions", 1078 "WhereOptions", 1079 "RankOptions", 1080 "ReverseSequenceOptions", 1081 nullptr 1082 }; 1083 return names; 1084 } 1085 1086 inline const char *EnumNameBuiltinOptions(BuiltinOptions e) { 1087 const size_t index = static_cast<int>(e); 1088 return EnumNamesBuiltinOptions()[index]; 1089 } 1090 1091 template<typename T> struct BuiltinOptionsTraits { 1092 static const BuiltinOptions enum_value = BuiltinOptions_NONE; 1093 }; 1094 1095 template<> struct BuiltinOptionsTraits<Conv2DOptions> { 1096 static const BuiltinOptions enum_value = BuiltinOptions_Conv2DOptions; 1097 }; 1098 1099 template<> struct BuiltinOptionsTraits<DepthwiseConv2DOptions> { 1100 static const BuiltinOptions enum_value = BuiltinOptions_DepthwiseConv2DOptions; 1101 }; 1102 1103 template<> struct BuiltinOptionsTraits<ConcatEmbeddingsOptions> { 1104 static const BuiltinOptions enum_value = BuiltinOptions_ConcatEmbeddingsOptions; 1105 }; 1106 1107 template<> struct BuiltinOptionsTraits<LSHProjectionOptions> { 1108 static const BuiltinOptions enum_value = BuiltinOptions_LSHProjectionOptions; 1109 }; 1110 1111 template<> struct BuiltinOptionsTraits<Pool2DOptions> { 1112 static const BuiltinOptions enum_value = BuiltinOptions_Pool2DOptions; 1113 }; 1114 1115 template<> struct BuiltinOptionsTraits<SVDFOptions> { 1116 static const BuiltinOptions enum_value = BuiltinOptions_SVDFOptions; 1117 }; 1118 1119 template<> struct BuiltinOptionsTraits<RNNOptions> { 1120 static const BuiltinOptions enum_value = BuiltinOptions_RNNOptions; 1121 }; 1122 1123 template<> struct BuiltinOptionsTraits<FullyConnectedOptions> { 1124 static const BuiltinOptions enum_value = BuiltinOptions_FullyConnectedOptions; 1125 }; 1126 1127 template<> struct BuiltinOptionsTraits<SoftmaxOptions> { 1128 static const BuiltinOptions enum_value = BuiltinOptions_SoftmaxOptions; 1129 }; 1130 1131 template<> struct BuiltinOptionsTraits<ConcatenationOptions> { 1132 static const BuiltinOptions enum_value = BuiltinOptions_ConcatenationOptions; 1133 }; 1134 1135 template<> struct BuiltinOptionsTraits<AddOptions> { 1136 static const BuiltinOptions enum_value = BuiltinOptions_AddOptions; 1137 }; 1138 1139 template<> struct BuiltinOptionsTraits<L2NormOptions> { 1140 static const BuiltinOptions enum_value = BuiltinOptions_L2NormOptions; 1141 }; 1142 1143 template<> struct BuiltinOptionsTraits<LocalResponseNormalizationOptions> { 1144 static const BuiltinOptions enum_value = BuiltinOptions_LocalResponseNormalizationOptions; 1145 }; 1146 1147 template<> struct BuiltinOptionsTraits<LSTMOptions> { 1148 static const BuiltinOptions enum_value = BuiltinOptions_LSTMOptions; 1149 }; 1150 1151 template<> struct BuiltinOptionsTraits<ResizeBilinearOptions> { 1152 static const BuiltinOptions enum_value = BuiltinOptions_ResizeBilinearOptions; 1153 }; 1154 1155 template<> struct BuiltinOptionsTraits<CallOptions> { 1156 static const BuiltinOptions enum_value = BuiltinOptions_CallOptions; 1157 }; 1158 1159 template<> struct BuiltinOptionsTraits<ReshapeOptions> { 1160 static const BuiltinOptions enum_value = BuiltinOptions_ReshapeOptions; 1161 }; 1162 1163 template<> struct BuiltinOptionsTraits<SkipGramOptions> { 1164 static const BuiltinOptions enum_value = BuiltinOptions_SkipGramOptions; 1165 }; 1166 1167 template<> struct BuiltinOptionsTraits<SpaceToDepthOptions> { 1168 static const BuiltinOptions enum_value = BuiltinOptions_SpaceToDepthOptions; 1169 }; 1170 1171 template<> struct BuiltinOptionsTraits<EmbeddingLookupSparseOptions> { 1172 static const BuiltinOptions enum_value = BuiltinOptions_EmbeddingLookupSparseOptions; 1173 }; 1174 1175 template<> struct BuiltinOptionsTraits<MulOptions> { 1176 static const BuiltinOptions enum_value = BuiltinOptions_MulOptions; 1177 }; 1178 1179 template<> struct BuiltinOptionsTraits<PadOptions> { 1180 static const BuiltinOptions enum_value = BuiltinOptions_PadOptions; 1181 }; 1182 1183 template<> struct BuiltinOptionsTraits<GatherOptions> { 1184 static const BuiltinOptions enum_value = BuiltinOptions_GatherOptions; 1185 }; 1186 1187 template<> struct BuiltinOptionsTraits<BatchToSpaceNDOptions> { 1188 static const BuiltinOptions enum_value = BuiltinOptions_BatchToSpaceNDOptions; 1189 }; 1190 1191 template<> struct BuiltinOptionsTraits<SpaceToBatchNDOptions> { 1192 static const BuiltinOptions enum_value = BuiltinOptions_SpaceToBatchNDOptions; 1193 }; 1194 1195 template<> struct BuiltinOptionsTraits<TransposeOptions> { 1196 static const BuiltinOptions enum_value = BuiltinOptions_TransposeOptions; 1197 }; 1198 1199 template<> struct BuiltinOptionsTraits<ReducerOptions> { 1200 static const BuiltinOptions enum_value = BuiltinOptions_ReducerOptions; 1201 }; 1202 1203 template<> struct BuiltinOptionsTraits<SubOptions> { 1204 static const BuiltinOptions enum_value = BuiltinOptions_SubOptions; 1205 }; 1206 1207 template<> struct BuiltinOptionsTraits<DivOptions> { 1208 static const BuiltinOptions enum_value = BuiltinOptions_DivOptions; 1209 }; 1210 1211 template<> struct BuiltinOptionsTraits<SqueezeOptions> { 1212 static const BuiltinOptions enum_value = BuiltinOptions_SqueezeOptions; 1213 }; 1214 1215 template<> struct BuiltinOptionsTraits<SequenceRNNOptions> { 1216 static const BuiltinOptions enum_value = BuiltinOptions_SequenceRNNOptions; 1217 }; 1218 1219 template<> struct BuiltinOptionsTraits<StridedSliceOptions> { 1220 static const BuiltinOptions enum_value = BuiltinOptions_StridedSliceOptions; 1221 }; 1222 1223 template<> struct BuiltinOptionsTraits<ExpOptions> { 1224 static const BuiltinOptions enum_value = BuiltinOptions_ExpOptions; 1225 }; 1226 1227 template<> struct BuiltinOptionsTraits<TopKV2Options> { 1228 static const BuiltinOptions enum_value = BuiltinOptions_TopKV2Options; 1229 }; 1230 1231 template<> struct BuiltinOptionsTraits<SplitOptions> { 1232 static const BuiltinOptions enum_value = BuiltinOptions_SplitOptions; 1233 }; 1234 1235 template<> struct BuiltinOptionsTraits<LogSoftmaxOptions> { 1236 static const BuiltinOptions enum_value = BuiltinOptions_LogSoftmaxOptions; 1237 }; 1238 1239 template<> struct BuiltinOptionsTraits<CastOptions> { 1240 static const BuiltinOptions enum_value = BuiltinOptions_CastOptions; 1241 }; 1242 1243 template<> struct BuiltinOptionsTraits<DequantizeOptions> { 1244 static const BuiltinOptions enum_value = BuiltinOptions_DequantizeOptions; 1245 }; 1246 1247 template<> struct BuiltinOptionsTraits<MaximumMinimumOptions> { 1248 static const BuiltinOptions enum_value = BuiltinOptions_MaximumMinimumOptions; 1249 }; 1250 1251 template<> struct BuiltinOptionsTraits<ArgMaxOptions> { 1252 static const BuiltinOptions enum_value = BuiltinOptions_ArgMaxOptions; 1253 }; 1254 1255 template<> struct BuiltinOptionsTraits<LessOptions> { 1256 static const BuiltinOptions enum_value = BuiltinOptions_LessOptions; 1257 }; 1258 1259 template<> struct BuiltinOptionsTraits<NegOptions> { 1260 static const BuiltinOptions enum_value = BuiltinOptions_NegOptions; 1261 }; 1262 1263 template<> struct BuiltinOptionsTraits<PadV2Options> { 1264 static const BuiltinOptions enum_value = BuiltinOptions_PadV2Options; 1265 }; 1266 1267 template<> struct BuiltinOptionsTraits<GreaterOptions> { 1268 static const BuiltinOptions enum_value = BuiltinOptions_GreaterOptions; 1269 }; 1270 1271 template<> struct BuiltinOptionsTraits<GreaterEqualOptions> { 1272 static const BuiltinOptions enum_value = BuiltinOptions_GreaterEqualOptions; 1273 }; 1274 1275 template<> struct BuiltinOptionsTraits<LessEqualOptions> { 1276 static const BuiltinOptions enum_value = BuiltinOptions_LessEqualOptions; 1277 }; 1278 1279 template<> struct BuiltinOptionsTraits<SelectOptions> { 1280 static const BuiltinOptions enum_value = BuiltinOptions_SelectOptions; 1281 }; 1282 1283 template<> struct BuiltinOptionsTraits<SliceOptions> { 1284 static const BuiltinOptions enum_value = BuiltinOptions_SliceOptions; 1285 }; 1286 1287 template<> struct BuiltinOptionsTraits<TransposeConvOptions> { 1288 static const BuiltinOptions enum_value = BuiltinOptions_TransposeConvOptions; 1289 }; 1290 1291 template<> struct BuiltinOptionsTraits<SparseToDenseOptions> { 1292 static const BuiltinOptions enum_value = BuiltinOptions_SparseToDenseOptions; 1293 }; 1294 1295 template<> struct BuiltinOptionsTraits<TileOptions> { 1296 static const BuiltinOptions enum_value = BuiltinOptions_TileOptions; 1297 }; 1298 1299 template<> struct BuiltinOptionsTraits<ExpandDimsOptions> { 1300 static const BuiltinOptions enum_value = BuiltinOptions_ExpandDimsOptions; 1301 }; 1302 1303 template<> struct BuiltinOptionsTraits<EqualOptions> { 1304 static const BuiltinOptions enum_value = BuiltinOptions_EqualOptions; 1305 }; 1306 1307 template<> struct BuiltinOptionsTraits<NotEqualOptions> { 1308 static const BuiltinOptions enum_value = BuiltinOptions_NotEqualOptions; 1309 }; 1310 1311 template<> struct BuiltinOptionsTraits<ShapeOptions> { 1312 static const BuiltinOptions enum_value = BuiltinOptions_ShapeOptions; 1313 }; 1314 1315 template<> struct BuiltinOptionsTraits<PowOptions> { 1316 static const BuiltinOptions enum_value = BuiltinOptions_PowOptions; 1317 }; 1318 1319 template<> struct BuiltinOptionsTraits<ArgMinOptions> { 1320 static const BuiltinOptions enum_value = BuiltinOptions_ArgMinOptions; 1321 }; 1322 1323 template<> struct BuiltinOptionsTraits<FakeQuantOptions> { 1324 static const BuiltinOptions enum_value = BuiltinOptions_FakeQuantOptions; 1325 }; 1326 1327 template<> struct BuiltinOptionsTraits<PackOptions> { 1328 static const BuiltinOptions enum_value = BuiltinOptions_PackOptions; 1329 }; 1330 1331 template<> struct BuiltinOptionsTraits<LogicalOrOptions> { 1332 static const BuiltinOptions enum_value = BuiltinOptions_LogicalOrOptions; 1333 }; 1334 1335 template<> struct BuiltinOptionsTraits<OneHotOptions> { 1336 static const BuiltinOptions enum_value = BuiltinOptions_OneHotOptions; 1337 }; 1338 1339 template<> struct BuiltinOptionsTraits<LogicalAndOptions> { 1340 static const BuiltinOptions enum_value = BuiltinOptions_LogicalAndOptions; 1341 }; 1342 1343 template<> struct BuiltinOptionsTraits<LogicalNotOptions> { 1344 static const BuiltinOptions enum_value = BuiltinOptions_LogicalNotOptions; 1345 }; 1346 1347 template<> struct BuiltinOptionsTraits<UnpackOptions> { 1348 static const BuiltinOptions enum_value = BuiltinOptions_UnpackOptions; 1349 }; 1350 1351 template<> struct BuiltinOptionsTraits<FloorDivOptions> { 1352 static const BuiltinOptions enum_value = BuiltinOptions_FloorDivOptions; 1353 }; 1354 1355 template<> struct BuiltinOptionsTraits<SquareOptions> { 1356 static const BuiltinOptions enum_value = BuiltinOptions_SquareOptions; 1357 }; 1358 1359 template<> struct BuiltinOptionsTraits<ZerosLikeOptions> { 1360 static const BuiltinOptions enum_value = BuiltinOptions_ZerosLikeOptions; 1361 }; 1362 1363 template<> struct BuiltinOptionsTraits<FillOptions> { 1364 static const BuiltinOptions enum_value = BuiltinOptions_FillOptions; 1365 }; 1366 1367 template<> struct BuiltinOptionsTraits<BidirectionalSequenceLSTMOptions> { 1368 static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceLSTMOptions; 1369 }; 1370 1371 template<> struct BuiltinOptionsTraits<BidirectionalSequenceRNNOptions> { 1372 static const BuiltinOptions enum_value = BuiltinOptions_BidirectionalSequenceRNNOptions; 1373 }; 1374 1375 template<> struct BuiltinOptionsTraits<UnidirectionalSequenceLSTMOptions> { 1376 static const BuiltinOptions enum_value = BuiltinOptions_UnidirectionalSequenceLSTMOptions; 1377 }; 1378 1379 template<> struct BuiltinOptionsTraits<FloorModOptions> { 1380 static const BuiltinOptions enum_value = BuiltinOptions_FloorModOptions; 1381 }; 1382 1383 template<> struct BuiltinOptionsTraits<RangeOptions> { 1384 static const BuiltinOptions enum_value = BuiltinOptions_RangeOptions; 1385 }; 1386 1387 template<> struct BuiltinOptionsTraits<ResizeNearestNeighborOptions> { 1388 static const BuiltinOptions enum_value = BuiltinOptions_ResizeNearestNeighborOptions; 1389 }; 1390 1391 template<> struct BuiltinOptionsTraits<LeakyReluOptions> { 1392 static const BuiltinOptions enum_value = BuiltinOptions_LeakyReluOptions; 1393 }; 1394 1395 template<> struct BuiltinOptionsTraits<SquaredDifferenceOptions> { 1396 static const BuiltinOptions enum_value = BuiltinOptions_SquaredDifferenceOptions; 1397 }; 1398 1399 template<> struct BuiltinOptionsTraits<MirrorPadOptions> { 1400 static const BuiltinOptions enum_value = BuiltinOptions_MirrorPadOptions; 1401 }; 1402 1403 template<> struct BuiltinOptionsTraits<AbsOptions> { 1404 static const BuiltinOptions enum_value = BuiltinOptions_AbsOptions; 1405 }; 1406 1407 template<> struct BuiltinOptionsTraits<SplitVOptions> { 1408 static const BuiltinOptions enum_value = BuiltinOptions_SplitVOptions; 1409 }; 1410 1411 template<> struct BuiltinOptionsTraits<UniqueOptions> { 1412 static const BuiltinOptions enum_value = BuiltinOptions_UniqueOptions; 1413 }; 1414 1415 template<> struct BuiltinOptionsTraits<ReverseV2Options> { 1416 static const BuiltinOptions enum_value = BuiltinOptions_ReverseV2Options; 1417 }; 1418 1419 template<> struct BuiltinOptionsTraits<AddNOptions> { 1420 static const BuiltinOptions enum_value = BuiltinOptions_AddNOptions; 1421 }; 1422 1423 template<> struct BuiltinOptionsTraits<GatherNdOptions> { 1424 static const BuiltinOptions enum_value = BuiltinOptions_GatherNdOptions; 1425 }; 1426 1427 template<> struct BuiltinOptionsTraits<CosOptions> { 1428 static const BuiltinOptions enum_value = BuiltinOptions_CosOptions; 1429 }; 1430 1431 template<> struct BuiltinOptionsTraits<WhereOptions> { 1432 static const BuiltinOptions enum_value = BuiltinOptions_WhereOptions; 1433 }; 1434 1435 template<> struct BuiltinOptionsTraits<RankOptions> { 1436 static const BuiltinOptions enum_value = BuiltinOptions_RankOptions; 1437 }; 1438 1439 template<> struct BuiltinOptionsTraits<ReverseSequenceOptions> { 1440 static const BuiltinOptions enum_value = BuiltinOptions_ReverseSequenceOptions; 1441 }; 1442 1443 struct BuiltinOptionsUnion { 1444 BuiltinOptions type; 1445 void *value; 1446 1447 BuiltinOptionsUnion() : type(BuiltinOptions_NONE), value(nullptr) {} 1448 BuiltinOptionsUnion(BuiltinOptionsUnion&& u) FLATBUFFERS_NOEXCEPT : 1449 type(BuiltinOptions_NONE), value(nullptr) 1450 { std::swap(type, u.type); std::swap(value, u.value); } 1451 BuiltinOptionsUnion(const BuiltinOptionsUnion &) FLATBUFFERS_NOEXCEPT; 1452 BuiltinOptionsUnion &operator=(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT 1453 { BuiltinOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } 1454 BuiltinOptionsUnion &operator=(BuiltinOptionsUnion &&u) FLATBUFFERS_NOEXCEPT 1455 { std::swap(type, u.type); std::swap(value, u.value); return *this; } 1456 ~BuiltinOptionsUnion() { Reset(); } 1457 1458 void Reset(); 1459 1460 #ifndef FLATBUFFERS_CPP98_STL 1461 template <typename T> 1462 void Set(T&& val) { 1463 Reset(); 1464 type = BuiltinOptionsTraits<typename T::TableType>::enum_value; 1465 if (type != BuiltinOptions_NONE) { 1466 value = new T(std::forward<T>(val)); 1467 } 1468 } 1469 #endif // FLATBUFFERS_CPP98_STL 1470 1471 static void *UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver); 1472 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 1473 1474 Conv2DOptionsT *AsConv2DOptions() { 1475 return type == BuiltinOptions_Conv2DOptions ? 1476 reinterpret_cast<Conv2DOptionsT *>(value) : nullptr; 1477 } 1478 const Conv2DOptionsT *AsConv2DOptions() const { 1479 return type == BuiltinOptions_Conv2DOptions ? 1480 reinterpret_cast<const Conv2DOptionsT *>(value) : nullptr; 1481 } 1482 DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() { 1483 return type == BuiltinOptions_DepthwiseConv2DOptions ? 1484 reinterpret_cast<DepthwiseConv2DOptionsT *>(value) : nullptr; 1485 } 1486 const DepthwiseConv2DOptionsT *AsDepthwiseConv2DOptions() const { 1487 return type == BuiltinOptions_DepthwiseConv2DOptions ? 1488 reinterpret_cast<const DepthwiseConv2DOptionsT *>(value) : nullptr; 1489 } 1490 ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() { 1491 return type == BuiltinOptions_ConcatEmbeddingsOptions ? 1492 reinterpret_cast<ConcatEmbeddingsOptionsT *>(value) : nullptr; 1493 } 1494 const ConcatEmbeddingsOptionsT *AsConcatEmbeddingsOptions() const { 1495 return type == BuiltinOptions_ConcatEmbeddingsOptions ? 1496 reinterpret_cast<const ConcatEmbeddingsOptionsT *>(value) : nullptr; 1497 } 1498 LSHProjectionOptionsT *AsLSHProjectionOptions() { 1499 return type == BuiltinOptions_LSHProjectionOptions ? 1500 reinterpret_cast<LSHProjectionOptionsT *>(value) : nullptr; 1501 } 1502 const LSHProjectionOptionsT *AsLSHProjectionOptions() const { 1503 return type == BuiltinOptions_LSHProjectionOptions ? 1504 reinterpret_cast<const LSHProjectionOptionsT *>(value) : nullptr; 1505 } 1506 Pool2DOptionsT *AsPool2DOptions() { 1507 return type == BuiltinOptions_Pool2DOptions ? 1508 reinterpret_cast<Pool2DOptionsT *>(value) : nullptr; 1509 } 1510 const Pool2DOptionsT *AsPool2DOptions() const { 1511 return type == BuiltinOptions_Pool2DOptions ? 1512 reinterpret_cast<const Pool2DOptionsT *>(value) : nullptr; 1513 } 1514 SVDFOptionsT *AsSVDFOptions() { 1515 return type == BuiltinOptions_SVDFOptions ? 1516 reinterpret_cast<SVDFOptionsT *>(value) : nullptr; 1517 } 1518 const SVDFOptionsT *AsSVDFOptions() const { 1519 return type == BuiltinOptions_SVDFOptions ? 1520 reinterpret_cast<const SVDFOptionsT *>(value) : nullptr; 1521 } 1522 RNNOptionsT *AsRNNOptions() { 1523 return type == BuiltinOptions_RNNOptions ? 1524 reinterpret_cast<RNNOptionsT *>(value) : nullptr; 1525 } 1526 const RNNOptionsT *AsRNNOptions() const { 1527 return type == BuiltinOptions_RNNOptions ? 1528 reinterpret_cast<const RNNOptionsT *>(value) : nullptr; 1529 } 1530 FullyConnectedOptionsT *AsFullyConnectedOptions() { 1531 return type == BuiltinOptions_FullyConnectedOptions ? 1532 reinterpret_cast<FullyConnectedOptionsT *>(value) : nullptr; 1533 } 1534 const FullyConnectedOptionsT *AsFullyConnectedOptions() const { 1535 return type == BuiltinOptions_FullyConnectedOptions ? 1536 reinterpret_cast<const FullyConnectedOptionsT *>(value) : nullptr; 1537 } 1538 SoftmaxOptionsT *AsSoftmaxOptions() { 1539 return type == BuiltinOptions_SoftmaxOptions ? 1540 reinterpret_cast<SoftmaxOptionsT *>(value) : nullptr; 1541 } 1542 const SoftmaxOptionsT *AsSoftmaxOptions() const { 1543 return type == BuiltinOptions_SoftmaxOptions ? 1544 reinterpret_cast<const SoftmaxOptionsT *>(value) : nullptr; 1545 } 1546 ConcatenationOptionsT *AsConcatenationOptions() { 1547 return type == BuiltinOptions_ConcatenationOptions ? 1548 reinterpret_cast<ConcatenationOptionsT *>(value) : nullptr; 1549 } 1550 const ConcatenationOptionsT *AsConcatenationOptions() const { 1551 return type == BuiltinOptions_ConcatenationOptions ? 1552 reinterpret_cast<const ConcatenationOptionsT *>(value) : nullptr; 1553 } 1554 AddOptionsT *AsAddOptions() { 1555 return type == BuiltinOptions_AddOptions ? 1556 reinterpret_cast<AddOptionsT *>(value) : nullptr; 1557 } 1558 const AddOptionsT *AsAddOptions() const { 1559 return type == BuiltinOptions_AddOptions ? 1560 reinterpret_cast<const AddOptionsT *>(value) : nullptr; 1561 } 1562 L2NormOptionsT *AsL2NormOptions() { 1563 return type == BuiltinOptions_L2NormOptions ? 1564 reinterpret_cast<L2NormOptionsT *>(value) : nullptr; 1565 } 1566 const L2NormOptionsT *AsL2NormOptions() const { 1567 return type == BuiltinOptions_L2NormOptions ? 1568 reinterpret_cast<const L2NormOptionsT *>(value) : nullptr; 1569 } 1570 LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() { 1571 return type == BuiltinOptions_LocalResponseNormalizationOptions ? 1572 reinterpret_cast<LocalResponseNormalizationOptionsT *>(value) : nullptr; 1573 } 1574 const LocalResponseNormalizationOptionsT *AsLocalResponseNormalizationOptions() const { 1575 return type == BuiltinOptions_LocalResponseNormalizationOptions ? 1576 reinterpret_cast<const LocalResponseNormalizationOptionsT *>(value) : nullptr; 1577 } 1578 LSTMOptionsT *AsLSTMOptions() { 1579 return type == BuiltinOptions_LSTMOptions ? 1580 reinterpret_cast<LSTMOptionsT *>(value) : nullptr; 1581 } 1582 const LSTMOptionsT *AsLSTMOptions() const { 1583 return type == BuiltinOptions_LSTMOptions ? 1584 reinterpret_cast<const LSTMOptionsT *>(value) : nullptr; 1585 } 1586 ResizeBilinearOptionsT *AsResizeBilinearOptions() { 1587 return type == BuiltinOptions_ResizeBilinearOptions ? 1588 reinterpret_cast<ResizeBilinearOptionsT *>(value) : nullptr; 1589 } 1590 const ResizeBilinearOptionsT *AsResizeBilinearOptions() const { 1591 return type == BuiltinOptions_ResizeBilinearOptions ? 1592 reinterpret_cast<const ResizeBilinearOptionsT *>(value) : nullptr; 1593 } 1594 CallOptionsT *AsCallOptions() { 1595 return type == BuiltinOptions_CallOptions ? 1596 reinterpret_cast<CallOptionsT *>(value) : nullptr; 1597 } 1598 const CallOptionsT *AsCallOptions() const { 1599 return type == BuiltinOptions_CallOptions ? 1600 reinterpret_cast<const CallOptionsT *>(value) : nullptr; 1601 } 1602 ReshapeOptionsT *AsReshapeOptions() { 1603 return type == BuiltinOptions_ReshapeOptions ? 1604 reinterpret_cast<ReshapeOptionsT *>(value) : nullptr; 1605 } 1606 const ReshapeOptionsT *AsReshapeOptions() const { 1607 return type == BuiltinOptions_ReshapeOptions ? 1608 reinterpret_cast<const ReshapeOptionsT *>(value) : nullptr; 1609 } 1610 SkipGramOptionsT *AsSkipGramOptions() { 1611 return type == BuiltinOptions_SkipGramOptions ? 1612 reinterpret_cast<SkipGramOptionsT *>(value) : nullptr; 1613 } 1614 const SkipGramOptionsT *AsSkipGramOptions() const { 1615 return type == BuiltinOptions_SkipGramOptions ? 1616 reinterpret_cast<const SkipGramOptionsT *>(value) : nullptr; 1617 } 1618 SpaceToDepthOptionsT *AsSpaceToDepthOptions() { 1619 return type == BuiltinOptions_SpaceToDepthOptions ? 1620 reinterpret_cast<SpaceToDepthOptionsT *>(value) : nullptr; 1621 } 1622 const SpaceToDepthOptionsT *AsSpaceToDepthOptions() const { 1623 return type == BuiltinOptions_SpaceToDepthOptions ? 1624 reinterpret_cast<const SpaceToDepthOptionsT *>(value) : nullptr; 1625 } 1626 EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() { 1627 return type == BuiltinOptions_EmbeddingLookupSparseOptions ? 1628 reinterpret_cast<EmbeddingLookupSparseOptionsT *>(value) : nullptr; 1629 } 1630 const EmbeddingLookupSparseOptionsT *AsEmbeddingLookupSparseOptions() const { 1631 return type == BuiltinOptions_EmbeddingLookupSparseOptions ? 1632 reinterpret_cast<const EmbeddingLookupSparseOptionsT *>(value) : nullptr; 1633 } 1634 MulOptionsT *AsMulOptions() { 1635 return type == BuiltinOptions_MulOptions ? 1636 reinterpret_cast<MulOptionsT *>(value) : nullptr; 1637 } 1638 const MulOptionsT *AsMulOptions() const { 1639 return type == BuiltinOptions_MulOptions ? 1640 reinterpret_cast<const MulOptionsT *>(value) : nullptr; 1641 } 1642 PadOptionsT *AsPadOptions() { 1643 return type == BuiltinOptions_PadOptions ? 1644 reinterpret_cast<PadOptionsT *>(value) : nullptr; 1645 } 1646 const PadOptionsT *AsPadOptions() const { 1647 return type == BuiltinOptions_PadOptions ? 1648 reinterpret_cast<const PadOptionsT *>(value) : nullptr; 1649 } 1650 GatherOptionsT *AsGatherOptions() { 1651 return type == BuiltinOptions_GatherOptions ? 1652 reinterpret_cast<GatherOptionsT *>(value) : nullptr; 1653 } 1654 const GatherOptionsT *AsGatherOptions() const { 1655 return type == BuiltinOptions_GatherOptions ? 1656 reinterpret_cast<const GatherOptionsT *>(value) : nullptr; 1657 } 1658 BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() { 1659 return type == BuiltinOptions_BatchToSpaceNDOptions ? 1660 reinterpret_cast<BatchToSpaceNDOptionsT *>(value) : nullptr; 1661 } 1662 const BatchToSpaceNDOptionsT *AsBatchToSpaceNDOptions() const { 1663 return type == BuiltinOptions_BatchToSpaceNDOptions ? 1664 reinterpret_cast<const BatchToSpaceNDOptionsT *>(value) : nullptr; 1665 } 1666 SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() { 1667 return type == BuiltinOptions_SpaceToBatchNDOptions ? 1668 reinterpret_cast<SpaceToBatchNDOptionsT *>(value) : nullptr; 1669 } 1670 const SpaceToBatchNDOptionsT *AsSpaceToBatchNDOptions() const { 1671 return type == BuiltinOptions_SpaceToBatchNDOptions ? 1672 reinterpret_cast<const SpaceToBatchNDOptionsT *>(value) : nullptr; 1673 } 1674 TransposeOptionsT *AsTransposeOptions() { 1675 return type == BuiltinOptions_TransposeOptions ? 1676 reinterpret_cast<TransposeOptionsT *>(value) : nullptr; 1677 } 1678 const TransposeOptionsT *AsTransposeOptions() const { 1679 return type == BuiltinOptions_TransposeOptions ? 1680 reinterpret_cast<const TransposeOptionsT *>(value) : nullptr; 1681 } 1682 ReducerOptionsT *AsReducerOptions() { 1683 return type == BuiltinOptions_ReducerOptions ? 1684 reinterpret_cast<ReducerOptionsT *>(value) : nullptr; 1685 } 1686 const ReducerOptionsT *AsReducerOptions() const { 1687 return type == BuiltinOptions_ReducerOptions ? 1688 reinterpret_cast<const ReducerOptionsT *>(value) : nullptr; 1689 } 1690 SubOptionsT *AsSubOptions() { 1691 return type == BuiltinOptions_SubOptions ? 1692 reinterpret_cast<SubOptionsT *>(value) : nullptr; 1693 } 1694 const SubOptionsT *AsSubOptions() const { 1695 return type == BuiltinOptions_SubOptions ? 1696 reinterpret_cast<const SubOptionsT *>(value) : nullptr; 1697 } 1698 DivOptionsT *AsDivOptions() { 1699 return type == BuiltinOptions_DivOptions ? 1700 reinterpret_cast<DivOptionsT *>(value) : nullptr; 1701 } 1702 const DivOptionsT *AsDivOptions() const { 1703 return type == BuiltinOptions_DivOptions ? 1704 reinterpret_cast<const DivOptionsT *>(value) : nullptr; 1705 } 1706 SqueezeOptionsT *AsSqueezeOptions() { 1707 return type == BuiltinOptions_SqueezeOptions ? 1708 reinterpret_cast<SqueezeOptionsT *>(value) : nullptr; 1709 } 1710 const SqueezeOptionsT *AsSqueezeOptions() const { 1711 return type == BuiltinOptions_SqueezeOptions ? 1712 reinterpret_cast<const SqueezeOptionsT *>(value) : nullptr; 1713 } 1714 SequenceRNNOptionsT *AsSequenceRNNOptions() { 1715 return type == BuiltinOptions_SequenceRNNOptions ? 1716 reinterpret_cast<SequenceRNNOptionsT *>(value) : nullptr; 1717 } 1718 const SequenceRNNOptionsT *AsSequenceRNNOptions() const { 1719 return type == BuiltinOptions_SequenceRNNOptions ? 1720 reinterpret_cast<const SequenceRNNOptionsT *>(value) : nullptr; 1721 } 1722 StridedSliceOptionsT *AsStridedSliceOptions() { 1723 return type == BuiltinOptions_StridedSliceOptions ? 1724 reinterpret_cast<StridedSliceOptionsT *>(value) : nullptr; 1725 } 1726 const StridedSliceOptionsT *AsStridedSliceOptions() const { 1727 return type == BuiltinOptions_StridedSliceOptions ? 1728 reinterpret_cast<const StridedSliceOptionsT *>(value) : nullptr; 1729 } 1730 ExpOptionsT *AsExpOptions() { 1731 return type == BuiltinOptions_ExpOptions ? 1732 reinterpret_cast<ExpOptionsT *>(value) : nullptr; 1733 } 1734 const ExpOptionsT *AsExpOptions() const { 1735 return type == BuiltinOptions_ExpOptions ? 1736 reinterpret_cast<const ExpOptionsT *>(value) : nullptr; 1737 } 1738 TopKV2OptionsT *AsTopKV2Options() { 1739 return type == BuiltinOptions_TopKV2Options ? 1740 reinterpret_cast<TopKV2OptionsT *>(value) : nullptr; 1741 } 1742 const TopKV2OptionsT *AsTopKV2Options() const { 1743 return type == BuiltinOptions_TopKV2Options ? 1744 reinterpret_cast<const TopKV2OptionsT *>(value) : nullptr; 1745 } 1746 SplitOptionsT *AsSplitOptions() { 1747 return type == BuiltinOptions_SplitOptions ? 1748 reinterpret_cast<SplitOptionsT *>(value) : nullptr; 1749 } 1750 const SplitOptionsT *AsSplitOptions() const { 1751 return type == BuiltinOptions_SplitOptions ? 1752 reinterpret_cast<const SplitOptionsT *>(value) : nullptr; 1753 } 1754 LogSoftmaxOptionsT *AsLogSoftmaxOptions() { 1755 return type == BuiltinOptions_LogSoftmaxOptions ? 1756 reinterpret_cast<LogSoftmaxOptionsT *>(value) : nullptr; 1757 } 1758 const LogSoftmaxOptionsT *AsLogSoftmaxOptions() const { 1759 return type == BuiltinOptions_LogSoftmaxOptions ? 1760 reinterpret_cast<const LogSoftmaxOptionsT *>(value) : nullptr; 1761 } 1762 CastOptionsT *AsCastOptions() { 1763 return type == BuiltinOptions_CastOptions ? 1764 reinterpret_cast<CastOptionsT *>(value) : nullptr; 1765 } 1766 const CastOptionsT *AsCastOptions() const { 1767 return type == BuiltinOptions_CastOptions ? 1768 reinterpret_cast<const CastOptionsT *>(value) : nullptr; 1769 } 1770 DequantizeOptionsT *AsDequantizeOptions() { 1771 return type == BuiltinOptions_DequantizeOptions ? 1772 reinterpret_cast<DequantizeOptionsT *>(value) : nullptr; 1773 } 1774 const DequantizeOptionsT *AsDequantizeOptions() const { 1775 return type == BuiltinOptions_DequantizeOptions ? 1776 reinterpret_cast<const DequantizeOptionsT *>(value) : nullptr; 1777 } 1778 MaximumMinimumOptionsT *AsMaximumMinimumOptions() { 1779 return type == BuiltinOptions_MaximumMinimumOptions ? 1780 reinterpret_cast<MaximumMinimumOptionsT *>(value) : nullptr; 1781 } 1782 const MaximumMinimumOptionsT *AsMaximumMinimumOptions() const { 1783 return type == BuiltinOptions_MaximumMinimumOptions ? 1784 reinterpret_cast<const MaximumMinimumOptionsT *>(value) : nullptr; 1785 } 1786 ArgMaxOptionsT *AsArgMaxOptions() { 1787 return type == BuiltinOptions_ArgMaxOptions ? 1788 reinterpret_cast<ArgMaxOptionsT *>(value) : nullptr; 1789 } 1790 const ArgMaxOptionsT *AsArgMaxOptions() const { 1791 return type == BuiltinOptions_ArgMaxOptions ? 1792 reinterpret_cast<const ArgMaxOptionsT *>(value) : nullptr; 1793 } 1794 LessOptionsT *AsLessOptions() { 1795 return type == BuiltinOptions_LessOptions ? 1796 reinterpret_cast<LessOptionsT *>(value) : nullptr; 1797 } 1798 const LessOptionsT *AsLessOptions() const { 1799 return type == BuiltinOptions_LessOptions ? 1800 reinterpret_cast<const LessOptionsT *>(value) : nullptr; 1801 } 1802 NegOptionsT *AsNegOptions() { 1803 return type == BuiltinOptions_NegOptions ? 1804 reinterpret_cast<NegOptionsT *>(value) : nullptr; 1805 } 1806 const NegOptionsT *AsNegOptions() const { 1807 return type == BuiltinOptions_NegOptions ? 1808 reinterpret_cast<const NegOptionsT *>(value) : nullptr; 1809 } 1810 PadV2OptionsT *AsPadV2Options() { 1811 return type == BuiltinOptions_PadV2Options ? 1812 reinterpret_cast<PadV2OptionsT *>(value) : nullptr; 1813 } 1814 const PadV2OptionsT *AsPadV2Options() const { 1815 return type == BuiltinOptions_PadV2Options ? 1816 reinterpret_cast<const PadV2OptionsT *>(value) : nullptr; 1817 } 1818 GreaterOptionsT *AsGreaterOptions() { 1819 return type == BuiltinOptions_GreaterOptions ? 1820 reinterpret_cast<GreaterOptionsT *>(value) : nullptr; 1821 } 1822 const GreaterOptionsT *AsGreaterOptions() const { 1823 return type == BuiltinOptions_GreaterOptions ? 1824 reinterpret_cast<const GreaterOptionsT *>(value) : nullptr; 1825 } 1826 GreaterEqualOptionsT *AsGreaterEqualOptions() { 1827 return type == BuiltinOptions_GreaterEqualOptions ? 1828 reinterpret_cast<GreaterEqualOptionsT *>(value) : nullptr; 1829 } 1830 const GreaterEqualOptionsT *AsGreaterEqualOptions() const { 1831 return type == BuiltinOptions_GreaterEqualOptions ? 1832 reinterpret_cast<const GreaterEqualOptionsT *>(value) : nullptr; 1833 } 1834 LessEqualOptionsT *AsLessEqualOptions() { 1835 return type == BuiltinOptions_LessEqualOptions ? 1836 reinterpret_cast<LessEqualOptionsT *>(value) : nullptr; 1837 } 1838 const LessEqualOptionsT *AsLessEqualOptions() const { 1839 return type == BuiltinOptions_LessEqualOptions ? 1840 reinterpret_cast<const LessEqualOptionsT *>(value) : nullptr; 1841 } 1842 SelectOptionsT *AsSelectOptions() { 1843 return type == BuiltinOptions_SelectOptions ? 1844 reinterpret_cast<SelectOptionsT *>(value) : nullptr; 1845 } 1846 const SelectOptionsT *AsSelectOptions() const { 1847 return type == BuiltinOptions_SelectOptions ? 1848 reinterpret_cast<const SelectOptionsT *>(value) : nullptr; 1849 } 1850 SliceOptionsT *AsSliceOptions() { 1851 return type == BuiltinOptions_SliceOptions ? 1852 reinterpret_cast<SliceOptionsT *>(value) : nullptr; 1853 } 1854 const SliceOptionsT *AsSliceOptions() const { 1855 return type == BuiltinOptions_SliceOptions ? 1856 reinterpret_cast<const SliceOptionsT *>(value) : nullptr; 1857 } 1858 TransposeConvOptionsT *AsTransposeConvOptions() { 1859 return type == BuiltinOptions_TransposeConvOptions ? 1860 reinterpret_cast<TransposeConvOptionsT *>(value) : nullptr; 1861 } 1862 const TransposeConvOptionsT *AsTransposeConvOptions() const { 1863 return type == BuiltinOptions_TransposeConvOptions ? 1864 reinterpret_cast<const TransposeConvOptionsT *>(value) : nullptr; 1865 } 1866 SparseToDenseOptionsT *AsSparseToDenseOptions() { 1867 return type == BuiltinOptions_SparseToDenseOptions ? 1868 reinterpret_cast<SparseToDenseOptionsT *>(value) : nullptr; 1869 } 1870 const SparseToDenseOptionsT *AsSparseToDenseOptions() const { 1871 return type == BuiltinOptions_SparseToDenseOptions ? 1872 reinterpret_cast<const SparseToDenseOptionsT *>(value) : nullptr; 1873 } 1874 TileOptionsT *AsTileOptions() { 1875 return type == BuiltinOptions_TileOptions ? 1876 reinterpret_cast<TileOptionsT *>(value) : nullptr; 1877 } 1878 const TileOptionsT *AsTileOptions() const { 1879 return type == BuiltinOptions_TileOptions ? 1880 reinterpret_cast<const TileOptionsT *>(value) : nullptr; 1881 } 1882 ExpandDimsOptionsT *AsExpandDimsOptions() { 1883 return type == BuiltinOptions_ExpandDimsOptions ? 1884 reinterpret_cast<ExpandDimsOptionsT *>(value) : nullptr; 1885 } 1886 const ExpandDimsOptionsT *AsExpandDimsOptions() const { 1887 return type == BuiltinOptions_ExpandDimsOptions ? 1888 reinterpret_cast<const ExpandDimsOptionsT *>(value) : nullptr; 1889 } 1890 EqualOptionsT *AsEqualOptions() { 1891 return type == BuiltinOptions_EqualOptions ? 1892 reinterpret_cast<EqualOptionsT *>(value) : nullptr; 1893 } 1894 const EqualOptionsT *AsEqualOptions() const { 1895 return type == BuiltinOptions_EqualOptions ? 1896 reinterpret_cast<const EqualOptionsT *>(value) : nullptr; 1897 } 1898 NotEqualOptionsT *AsNotEqualOptions() { 1899 return type == BuiltinOptions_NotEqualOptions ? 1900 reinterpret_cast<NotEqualOptionsT *>(value) : nullptr; 1901 } 1902 const NotEqualOptionsT *AsNotEqualOptions() const { 1903 return type == BuiltinOptions_NotEqualOptions ? 1904 reinterpret_cast<const NotEqualOptionsT *>(value) : nullptr; 1905 } 1906 ShapeOptionsT *AsShapeOptions() { 1907 return type == BuiltinOptions_ShapeOptions ? 1908 reinterpret_cast<ShapeOptionsT *>(value) : nullptr; 1909 } 1910 const ShapeOptionsT *AsShapeOptions() const { 1911 return type == BuiltinOptions_ShapeOptions ? 1912 reinterpret_cast<const ShapeOptionsT *>(value) : nullptr; 1913 } 1914 PowOptionsT *AsPowOptions() { 1915 return type == BuiltinOptions_PowOptions ? 1916 reinterpret_cast<PowOptionsT *>(value) : nullptr; 1917 } 1918 const PowOptionsT *AsPowOptions() const { 1919 return type == BuiltinOptions_PowOptions ? 1920 reinterpret_cast<const PowOptionsT *>(value) : nullptr; 1921 } 1922 ArgMinOptionsT *AsArgMinOptions() { 1923 return type == BuiltinOptions_ArgMinOptions ? 1924 reinterpret_cast<ArgMinOptionsT *>(value) : nullptr; 1925 } 1926 const ArgMinOptionsT *AsArgMinOptions() const { 1927 return type == BuiltinOptions_ArgMinOptions ? 1928 reinterpret_cast<const ArgMinOptionsT *>(value) : nullptr; 1929 } 1930 FakeQuantOptionsT *AsFakeQuantOptions() { 1931 return type == BuiltinOptions_FakeQuantOptions ? 1932 reinterpret_cast<FakeQuantOptionsT *>(value) : nullptr; 1933 } 1934 const FakeQuantOptionsT *AsFakeQuantOptions() const { 1935 return type == BuiltinOptions_FakeQuantOptions ? 1936 reinterpret_cast<const FakeQuantOptionsT *>(value) : nullptr; 1937 } 1938 PackOptionsT *AsPackOptions() { 1939 return type == BuiltinOptions_PackOptions ? 1940 reinterpret_cast<PackOptionsT *>(value) : nullptr; 1941 } 1942 const PackOptionsT *AsPackOptions() const { 1943 return type == BuiltinOptions_PackOptions ? 1944 reinterpret_cast<const PackOptionsT *>(value) : nullptr; 1945 } 1946 LogicalOrOptionsT *AsLogicalOrOptions() { 1947 return type == BuiltinOptions_LogicalOrOptions ? 1948 reinterpret_cast<LogicalOrOptionsT *>(value) : nullptr; 1949 } 1950 const LogicalOrOptionsT *AsLogicalOrOptions() const { 1951 return type == BuiltinOptions_LogicalOrOptions ? 1952 reinterpret_cast<const LogicalOrOptionsT *>(value) : nullptr; 1953 } 1954 OneHotOptionsT *AsOneHotOptions() { 1955 return type == BuiltinOptions_OneHotOptions ? 1956 reinterpret_cast<OneHotOptionsT *>(value) : nullptr; 1957 } 1958 const OneHotOptionsT *AsOneHotOptions() const { 1959 return type == BuiltinOptions_OneHotOptions ? 1960 reinterpret_cast<const OneHotOptionsT *>(value) : nullptr; 1961 } 1962 LogicalAndOptionsT *AsLogicalAndOptions() { 1963 return type == BuiltinOptions_LogicalAndOptions ? 1964 reinterpret_cast<LogicalAndOptionsT *>(value) : nullptr; 1965 } 1966 const LogicalAndOptionsT *AsLogicalAndOptions() const { 1967 return type == BuiltinOptions_LogicalAndOptions ? 1968 reinterpret_cast<const LogicalAndOptionsT *>(value) : nullptr; 1969 } 1970 LogicalNotOptionsT *AsLogicalNotOptions() { 1971 return type == BuiltinOptions_LogicalNotOptions ? 1972 reinterpret_cast<LogicalNotOptionsT *>(value) : nullptr; 1973 } 1974 const LogicalNotOptionsT *AsLogicalNotOptions() const { 1975 return type == BuiltinOptions_LogicalNotOptions ? 1976 reinterpret_cast<const LogicalNotOptionsT *>(value) : nullptr; 1977 } 1978 UnpackOptionsT *AsUnpackOptions() { 1979 return type == BuiltinOptions_UnpackOptions ? 1980 reinterpret_cast<UnpackOptionsT *>(value) : nullptr; 1981 } 1982 const UnpackOptionsT *AsUnpackOptions() const { 1983 return type == BuiltinOptions_UnpackOptions ? 1984 reinterpret_cast<const UnpackOptionsT *>(value) : nullptr; 1985 } 1986 FloorDivOptionsT *AsFloorDivOptions() { 1987 return type == BuiltinOptions_FloorDivOptions ? 1988 reinterpret_cast<FloorDivOptionsT *>(value) : nullptr; 1989 } 1990 const FloorDivOptionsT *AsFloorDivOptions() const { 1991 return type == BuiltinOptions_FloorDivOptions ? 1992 reinterpret_cast<const FloorDivOptionsT *>(value) : nullptr; 1993 } 1994 SquareOptionsT *AsSquareOptions() { 1995 return type == BuiltinOptions_SquareOptions ? 1996 reinterpret_cast<SquareOptionsT *>(value) : nullptr; 1997 } 1998 const SquareOptionsT *AsSquareOptions() const { 1999 return type == BuiltinOptions_SquareOptions ? 2000 reinterpret_cast<const SquareOptionsT *>(value) : nullptr; 2001 } 2002 ZerosLikeOptionsT *AsZerosLikeOptions() { 2003 return type == BuiltinOptions_ZerosLikeOptions ? 2004 reinterpret_cast<ZerosLikeOptionsT *>(value) : nullptr; 2005 } 2006 const ZerosLikeOptionsT *AsZerosLikeOptions() const { 2007 return type == BuiltinOptions_ZerosLikeOptions ? 2008 reinterpret_cast<const ZerosLikeOptionsT *>(value) : nullptr; 2009 } 2010 FillOptionsT *AsFillOptions() { 2011 return type == BuiltinOptions_FillOptions ? 2012 reinterpret_cast<FillOptionsT *>(value) : nullptr; 2013 } 2014 const FillOptionsT *AsFillOptions() const { 2015 return type == BuiltinOptions_FillOptions ? 2016 reinterpret_cast<const FillOptionsT *>(value) : nullptr; 2017 } 2018 BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() { 2019 return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ? 2020 reinterpret_cast<BidirectionalSequenceLSTMOptionsT *>(value) : nullptr; 2021 } 2022 const BidirectionalSequenceLSTMOptionsT *AsBidirectionalSequenceLSTMOptions() const { 2023 return type == BuiltinOptions_BidirectionalSequenceLSTMOptions ? 2024 reinterpret_cast<const BidirectionalSequenceLSTMOptionsT *>(value) : nullptr; 2025 } 2026 BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() { 2027 return type == BuiltinOptions_BidirectionalSequenceRNNOptions ? 2028 reinterpret_cast<BidirectionalSequenceRNNOptionsT *>(value) : nullptr; 2029 } 2030 const BidirectionalSequenceRNNOptionsT *AsBidirectionalSequenceRNNOptions() const { 2031 return type == BuiltinOptions_BidirectionalSequenceRNNOptions ? 2032 reinterpret_cast<const BidirectionalSequenceRNNOptionsT *>(value) : nullptr; 2033 } 2034 UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() { 2035 return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ? 2036 reinterpret_cast<UnidirectionalSequenceLSTMOptionsT *>(value) : nullptr; 2037 } 2038 const UnidirectionalSequenceLSTMOptionsT *AsUnidirectionalSequenceLSTMOptions() const { 2039 return type == BuiltinOptions_UnidirectionalSequenceLSTMOptions ? 2040 reinterpret_cast<const UnidirectionalSequenceLSTMOptionsT *>(value) : nullptr; 2041 } 2042 FloorModOptionsT *AsFloorModOptions() { 2043 return type == BuiltinOptions_FloorModOptions ? 2044 reinterpret_cast<FloorModOptionsT *>(value) : nullptr; 2045 } 2046 const FloorModOptionsT *AsFloorModOptions() const { 2047 return type == BuiltinOptions_FloorModOptions ? 2048 reinterpret_cast<const FloorModOptionsT *>(value) : nullptr; 2049 } 2050 RangeOptionsT *AsRangeOptions() { 2051 return type == BuiltinOptions_RangeOptions ? 2052 reinterpret_cast<RangeOptionsT *>(value) : nullptr; 2053 } 2054 const RangeOptionsT *AsRangeOptions() const { 2055 return type == BuiltinOptions_RangeOptions ? 2056 reinterpret_cast<const RangeOptionsT *>(value) : nullptr; 2057 } 2058 ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() { 2059 return type == BuiltinOptions_ResizeNearestNeighborOptions ? 2060 reinterpret_cast<ResizeNearestNeighborOptionsT *>(value) : nullptr; 2061 } 2062 const ResizeNearestNeighborOptionsT *AsResizeNearestNeighborOptions() const { 2063 return type == BuiltinOptions_ResizeNearestNeighborOptions ? 2064 reinterpret_cast<const ResizeNearestNeighborOptionsT *>(value) : nullptr; 2065 } 2066 LeakyReluOptionsT *AsLeakyReluOptions() { 2067 return type == BuiltinOptions_LeakyReluOptions ? 2068 reinterpret_cast<LeakyReluOptionsT *>(value) : nullptr; 2069 } 2070 const LeakyReluOptionsT *AsLeakyReluOptions() const { 2071 return type == BuiltinOptions_LeakyReluOptions ? 2072 reinterpret_cast<const LeakyReluOptionsT *>(value) : nullptr; 2073 } 2074 SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() { 2075 return type == BuiltinOptions_SquaredDifferenceOptions ? 2076 reinterpret_cast<SquaredDifferenceOptionsT *>(value) : nullptr; 2077 } 2078 const SquaredDifferenceOptionsT *AsSquaredDifferenceOptions() const { 2079 return type == BuiltinOptions_SquaredDifferenceOptions ? 2080 reinterpret_cast<const SquaredDifferenceOptionsT *>(value) : nullptr; 2081 } 2082 MirrorPadOptionsT *AsMirrorPadOptions() { 2083 return type == BuiltinOptions_MirrorPadOptions ? 2084 reinterpret_cast<MirrorPadOptionsT *>(value) : nullptr; 2085 } 2086 const MirrorPadOptionsT *AsMirrorPadOptions() const { 2087 return type == BuiltinOptions_MirrorPadOptions ? 2088 reinterpret_cast<const MirrorPadOptionsT *>(value) : nullptr; 2089 } 2090 AbsOptionsT *AsAbsOptions() { 2091 return type == BuiltinOptions_AbsOptions ? 2092 reinterpret_cast<AbsOptionsT *>(value) : nullptr; 2093 } 2094 const AbsOptionsT *AsAbsOptions() const { 2095 return type == BuiltinOptions_AbsOptions ? 2096 reinterpret_cast<const AbsOptionsT *>(value) : nullptr; 2097 } 2098 SplitVOptionsT *AsSplitVOptions() { 2099 return type == BuiltinOptions_SplitVOptions ? 2100 reinterpret_cast<SplitVOptionsT *>(value) : nullptr; 2101 } 2102 const SplitVOptionsT *AsSplitVOptions() const { 2103 return type == BuiltinOptions_SplitVOptions ? 2104 reinterpret_cast<const SplitVOptionsT *>(value) : nullptr; 2105 } 2106 UniqueOptionsT *AsUniqueOptions() { 2107 return type == BuiltinOptions_UniqueOptions ? 2108 reinterpret_cast<UniqueOptionsT *>(value) : nullptr; 2109 } 2110 const UniqueOptionsT *AsUniqueOptions() const { 2111 return type == BuiltinOptions_UniqueOptions ? 2112 reinterpret_cast<const UniqueOptionsT *>(value) : nullptr; 2113 } 2114 ReverseV2OptionsT *AsReverseV2Options() { 2115 return type == BuiltinOptions_ReverseV2Options ? 2116 reinterpret_cast<ReverseV2OptionsT *>(value) : nullptr; 2117 } 2118 const ReverseV2OptionsT *AsReverseV2Options() const { 2119 return type == BuiltinOptions_ReverseV2Options ? 2120 reinterpret_cast<const ReverseV2OptionsT *>(value) : nullptr; 2121 } 2122 AddNOptionsT *AsAddNOptions() { 2123 return type == BuiltinOptions_AddNOptions ? 2124 reinterpret_cast<AddNOptionsT *>(value) : nullptr; 2125 } 2126 const AddNOptionsT *AsAddNOptions() const { 2127 return type == BuiltinOptions_AddNOptions ? 2128 reinterpret_cast<const AddNOptionsT *>(value) : nullptr; 2129 } 2130 GatherNdOptionsT *AsGatherNdOptions() { 2131 return type == BuiltinOptions_GatherNdOptions ? 2132 reinterpret_cast<GatherNdOptionsT *>(value) : nullptr; 2133 } 2134 const GatherNdOptionsT *AsGatherNdOptions() const { 2135 return type == BuiltinOptions_GatherNdOptions ? 2136 reinterpret_cast<const GatherNdOptionsT *>(value) : nullptr; 2137 } 2138 CosOptionsT *AsCosOptions() { 2139 return type == BuiltinOptions_CosOptions ? 2140 reinterpret_cast<CosOptionsT *>(value) : nullptr; 2141 } 2142 const CosOptionsT *AsCosOptions() const { 2143 return type == BuiltinOptions_CosOptions ? 2144 reinterpret_cast<const CosOptionsT *>(value) : nullptr; 2145 } 2146 WhereOptionsT *AsWhereOptions() { 2147 return type == BuiltinOptions_WhereOptions ? 2148 reinterpret_cast<WhereOptionsT *>(value) : nullptr; 2149 } 2150 const WhereOptionsT *AsWhereOptions() const { 2151 return type == BuiltinOptions_WhereOptions ? 2152 reinterpret_cast<const WhereOptionsT *>(value) : nullptr; 2153 } 2154 RankOptionsT *AsRankOptions() { 2155 return type == BuiltinOptions_RankOptions ? 2156 reinterpret_cast<RankOptionsT *>(value) : nullptr; 2157 } 2158 const RankOptionsT *AsRankOptions() const { 2159 return type == BuiltinOptions_RankOptions ? 2160 reinterpret_cast<const RankOptionsT *>(value) : nullptr; 2161 } 2162 ReverseSequenceOptionsT *AsReverseSequenceOptions() { 2163 return type == BuiltinOptions_ReverseSequenceOptions ? 2164 reinterpret_cast<ReverseSequenceOptionsT *>(value) : nullptr; 2165 } 2166 const ReverseSequenceOptionsT *AsReverseSequenceOptions() const { 2167 return type == BuiltinOptions_ReverseSequenceOptions ? 2168 reinterpret_cast<const ReverseSequenceOptionsT *>(value) : nullptr; 2169 } 2170 }; 2171 2172 bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type); 2173 bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 2174 2175 enum Padding { 2176 Padding_SAME = 0, 2177 Padding_VALID = 1, 2178 Padding_MIN = Padding_SAME, 2179 Padding_MAX = Padding_VALID 2180 }; 2181 2182 inline const Padding (&EnumValuesPadding())[2] { 2183 static const Padding values[] = { 2184 Padding_SAME, 2185 Padding_VALID 2186 }; 2187 return values; 2188 } 2189 2190 inline const char * const *EnumNamesPadding() { 2191 static const char * const names[] = { 2192 "SAME", 2193 "VALID", 2194 nullptr 2195 }; 2196 return names; 2197 } 2198 2199 inline const char *EnumNamePadding(Padding e) { 2200 const size_t index = static_cast<int>(e); 2201 return EnumNamesPadding()[index]; 2202 } 2203 2204 enum ActivationFunctionType { 2205 ActivationFunctionType_NONE = 0, 2206 ActivationFunctionType_RELU = 1, 2207 ActivationFunctionType_RELU_N1_TO_1 = 2, 2208 ActivationFunctionType_RELU6 = 3, 2209 ActivationFunctionType_TANH = 4, 2210 ActivationFunctionType_SIGN_BIT = 5, 2211 ActivationFunctionType_MIN = ActivationFunctionType_NONE, 2212 ActivationFunctionType_MAX = ActivationFunctionType_SIGN_BIT 2213 }; 2214 2215 inline const ActivationFunctionType (&EnumValuesActivationFunctionType())[6] { 2216 static const ActivationFunctionType values[] = { 2217 ActivationFunctionType_NONE, 2218 ActivationFunctionType_RELU, 2219 ActivationFunctionType_RELU_N1_TO_1, 2220 ActivationFunctionType_RELU6, 2221 ActivationFunctionType_TANH, 2222 ActivationFunctionType_SIGN_BIT 2223 }; 2224 return values; 2225 } 2226 2227 inline const char * const *EnumNamesActivationFunctionType() { 2228 static const char * const names[] = { 2229 "NONE", 2230 "RELU", 2231 "RELU_N1_TO_1", 2232 "RELU6", 2233 "TANH", 2234 "SIGN_BIT", 2235 nullptr 2236 }; 2237 return names; 2238 } 2239 2240 inline const char *EnumNameActivationFunctionType(ActivationFunctionType e) { 2241 const size_t index = static_cast<int>(e); 2242 return EnumNamesActivationFunctionType()[index]; 2243 } 2244 2245 enum LSHProjectionType { 2246 LSHProjectionType_UNKNOWN = 0, 2247 LSHProjectionType_SPARSE = 1, 2248 LSHProjectionType_DENSE = 2, 2249 LSHProjectionType_MIN = LSHProjectionType_UNKNOWN, 2250 LSHProjectionType_MAX = LSHProjectionType_DENSE 2251 }; 2252 2253 inline const LSHProjectionType (&EnumValuesLSHProjectionType())[3] { 2254 static const LSHProjectionType values[] = { 2255 LSHProjectionType_UNKNOWN, 2256 LSHProjectionType_SPARSE, 2257 LSHProjectionType_DENSE 2258 }; 2259 return values; 2260 } 2261 2262 inline const char * const *EnumNamesLSHProjectionType() { 2263 static const char * const names[] = { 2264 "UNKNOWN", 2265 "SPARSE", 2266 "DENSE", 2267 nullptr 2268 }; 2269 return names; 2270 } 2271 2272 inline const char *EnumNameLSHProjectionType(LSHProjectionType e) { 2273 const size_t index = static_cast<int>(e); 2274 return EnumNamesLSHProjectionType()[index]; 2275 } 2276 2277 enum FullyConnectedOptionsWeightsFormat { 2278 FullyConnectedOptionsWeightsFormat_DEFAULT = 0, 2279 FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 = 1, 2280 FullyConnectedOptionsWeightsFormat_MIN = FullyConnectedOptionsWeightsFormat_DEFAULT, 2281 FullyConnectedOptionsWeightsFormat_MAX = FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 2282 }; 2283 2284 inline const FullyConnectedOptionsWeightsFormat (&EnumValuesFullyConnectedOptionsWeightsFormat())[2] { 2285 static const FullyConnectedOptionsWeightsFormat values[] = { 2286 FullyConnectedOptionsWeightsFormat_DEFAULT, 2287 FullyConnectedOptionsWeightsFormat_SHUFFLED4x16INT8 2288 }; 2289 return values; 2290 } 2291 2292 inline const char * const *EnumNamesFullyConnectedOptionsWeightsFormat() { 2293 static const char * const names[] = { 2294 "DEFAULT", 2295 "SHUFFLED4x16INT8", 2296 nullptr 2297 }; 2298 return names; 2299 } 2300 2301 inline const char *EnumNameFullyConnectedOptionsWeightsFormat(FullyConnectedOptionsWeightsFormat e) { 2302 const size_t index = static_cast<int>(e); 2303 return EnumNamesFullyConnectedOptionsWeightsFormat()[index]; 2304 } 2305 2306 enum LSTMKernelType { 2307 LSTMKernelType_FULL = 0, 2308 LSTMKernelType_BASIC = 1, 2309 LSTMKernelType_MIN = LSTMKernelType_FULL, 2310 LSTMKernelType_MAX = LSTMKernelType_BASIC 2311 }; 2312 2313 inline const LSTMKernelType (&EnumValuesLSTMKernelType())[2] { 2314 static const LSTMKernelType values[] = { 2315 LSTMKernelType_FULL, 2316 LSTMKernelType_BASIC 2317 }; 2318 return values; 2319 } 2320 2321 inline const char * const *EnumNamesLSTMKernelType() { 2322 static const char * const names[] = { 2323 "FULL", 2324 "BASIC", 2325 nullptr 2326 }; 2327 return names; 2328 } 2329 2330 inline const char *EnumNameLSTMKernelType(LSTMKernelType e) { 2331 const size_t index = static_cast<int>(e); 2332 return EnumNamesLSTMKernelType()[index]; 2333 } 2334 2335 enum CombinerType { 2336 CombinerType_SUM = 0, 2337 CombinerType_MEAN = 1, 2338 CombinerType_SQRTN = 2, 2339 CombinerType_MIN = CombinerType_SUM, 2340 CombinerType_MAX = CombinerType_SQRTN 2341 }; 2342 2343 inline const CombinerType (&EnumValuesCombinerType())[3] { 2344 static const CombinerType values[] = { 2345 CombinerType_SUM, 2346 CombinerType_MEAN, 2347 CombinerType_SQRTN 2348 }; 2349 return values; 2350 } 2351 2352 inline const char * const *EnumNamesCombinerType() { 2353 static const char * const names[] = { 2354 "SUM", 2355 "MEAN", 2356 "SQRTN", 2357 nullptr 2358 }; 2359 return names; 2360 } 2361 2362 inline const char *EnumNameCombinerType(CombinerType e) { 2363 const size_t index = static_cast<int>(e); 2364 return EnumNamesCombinerType()[index]; 2365 } 2366 2367 enum MirrorPadMode { 2368 MirrorPadMode_REFLECT = 0, 2369 MirrorPadMode_SYMMETRIC = 1, 2370 MirrorPadMode_MIN = MirrorPadMode_REFLECT, 2371 MirrorPadMode_MAX = MirrorPadMode_SYMMETRIC 2372 }; 2373 2374 inline const MirrorPadMode (&EnumValuesMirrorPadMode())[2] { 2375 static const MirrorPadMode values[] = { 2376 MirrorPadMode_REFLECT, 2377 MirrorPadMode_SYMMETRIC 2378 }; 2379 return values; 2380 } 2381 2382 inline const char * const *EnumNamesMirrorPadMode() { 2383 static const char * const names[] = { 2384 "REFLECT", 2385 "SYMMETRIC", 2386 nullptr 2387 }; 2388 return names; 2389 } 2390 2391 inline const char *EnumNameMirrorPadMode(MirrorPadMode e) { 2392 const size_t index = static_cast<int>(e); 2393 return EnumNamesMirrorPadMode()[index]; 2394 } 2395 2396 enum CustomOptionsFormat { 2397 CustomOptionsFormat_FLEXBUFFERS = 0, 2398 CustomOptionsFormat_MIN = CustomOptionsFormat_FLEXBUFFERS, 2399 CustomOptionsFormat_MAX = CustomOptionsFormat_FLEXBUFFERS 2400 }; 2401 2402 inline const CustomOptionsFormat (&EnumValuesCustomOptionsFormat())[1] { 2403 static const CustomOptionsFormat values[] = { 2404 CustomOptionsFormat_FLEXBUFFERS 2405 }; 2406 return values; 2407 } 2408 2409 inline const char * const *EnumNamesCustomOptionsFormat() { 2410 static const char * const names[] = { 2411 "FLEXBUFFERS", 2412 nullptr 2413 }; 2414 return names; 2415 } 2416 2417 inline const char *EnumNameCustomOptionsFormat(CustomOptionsFormat e) { 2418 const size_t index = static_cast<int>(e); 2419 return EnumNamesCustomOptionsFormat()[index]; 2420 } 2421 2422 struct CustomQuantizationT : public flatbuffers::NativeTable { 2423 typedef CustomQuantization TableType; 2424 std::vector<uint8_t> custom; 2425 CustomQuantizationT() { 2426 } 2427 }; 2428 2429 struct CustomQuantization FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 2430 typedef CustomQuantizationT NativeTableType; 2431 enum { 2432 VT_CUSTOM = 4 2433 }; 2434 const flatbuffers::Vector<uint8_t> *custom() const { 2435 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM); 2436 } 2437 bool Verify(flatbuffers::Verifier &verifier) const { 2438 return VerifyTableStart(verifier) && 2439 VerifyOffset(verifier, VT_CUSTOM) && 2440 verifier.VerifyVector(custom()) && 2441 verifier.EndTable(); 2442 } 2443 CustomQuantizationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2444 void UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2445 static flatbuffers::Offset<CustomQuantization> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2446 }; 2447 2448 struct CustomQuantizationBuilder { 2449 flatbuffers::FlatBufferBuilder &fbb_; 2450 flatbuffers::uoffset_t start_; 2451 void add_custom(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom) { 2452 fbb_.AddOffset(CustomQuantization::VT_CUSTOM, custom); 2453 } 2454 explicit CustomQuantizationBuilder(flatbuffers::FlatBufferBuilder &_fbb) 2455 : fbb_(_fbb) { 2456 start_ = fbb_.StartTable(); 2457 } 2458 CustomQuantizationBuilder &operator=(const CustomQuantizationBuilder &); 2459 flatbuffers::Offset<CustomQuantization> Finish() { 2460 const auto end = fbb_.EndTable(start_); 2461 auto o = flatbuffers::Offset<CustomQuantization>(end); 2462 return o; 2463 } 2464 }; 2465 2466 inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization( 2467 flatbuffers::FlatBufferBuilder &_fbb, 2468 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom = 0) { 2469 CustomQuantizationBuilder builder_(_fbb); 2470 builder_.add_custom(custom); 2471 return builder_.Finish(); 2472 } 2473 2474 inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantizationDirect( 2475 flatbuffers::FlatBufferBuilder &_fbb, 2476 const std::vector<uint8_t> *custom = nullptr) { 2477 return tflite::CreateCustomQuantization( 2478 _fbb, 2479 custom ? _fbb.CreateVector<uint8_t>(*custom) : 0); 2480 } 2481 2482 flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2483 2484 struct QuantizationParametersT : public flatbuffers::NativeTable { 2485 typedef QuantizationParameters TableType; 2486 std::vector<float> min; 2487 std::vector<float> max; 2488 std::vector<float> scale; 2489 std::vector<int64_t> zero_point; 2490 QuantizationDetailsUnion details; 2491 int32_t quantized_dimension; 2492 QuantizationParametersT() 2493 : quantized_dimension(0) { 2494 } 2495 }; 2496 2497 struct QuantizationParameters FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 2498 typedef QuantizationParametersT NativeTableType; 2499 enum { 2500 VT_MIN = 4, 2501 VT_MAX = 6, 2502 VT_SCALE = 8, 2503 VT_ZERO_POINT = 10, 2504 VT_DETAILS_TYPE = 12, 2505 VT_DETAILS = 14, 2506 VT_QUANTIZED_DIMENSION = 16 2507 }; 2508 const flatbuffers::Vector<float> *min() const { 2509 return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN); 2510 } 2511 const flatbuffers::Vector<float> *max() const { 2512 return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX); 2513 } 2514 const flatbuffers::Vector<float> *scale() const { 2515 return GetPointer<const flatbuffers::Vector<float> *>(VT_SCALE); 2516 } 2517 const flatbuffers::Vector<int64_t> *zero_point() const { 2518 return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_ZERO_POINT); 2519 } 2520 QuantizationDetails details_type() const { 2521 return static_cast<QuantizationDetails>(GetField<uint8_t>(VT_DETAILS_TYPE, 0)); 2522 } 2523 const void *details() const { 2524 return GetPointer<const void *>(VT_DETAILS); 2525 } 2526 template<typename T> const T *details_as() const; 2527 const CustomQuantization *details_as_CustomQuantization() const { 2528 return details_type() == QuantizationDetails_CustomQuantization ? static_cast<const CustomQuantization *>(details()) : nullptr; 2529 } 2530 int32_t quantized_dimension() const { 2531 return GetField<int32_t>(VT_QUANTIZED_DIMENSION, 0); 2532 } 2533 bool Verify(flatbuffers::Verifier &verifier) const { 2534 return VerifyTableStart(verifier) && 2535 VerifyOffset(verifier, VT_MIN) && 2536 verifier.VerifyVector(min()) && 2537 VerifyOffset(verifier, VT_MAX) && 2538 verifier.VerifyVector(max()) && 2539 VerifyOffset(verifier, VT_SCALE) && 2540 verifier.VerifyVector(scale()) && 2541 VerifyOffset(verifier, VT_ZERO_POINT) && 2542 verifier.VerifyVector(zero_point()) && 2543 VerifyField<uint8_t>(verifier, VT_DETAILS_TYPE) && 2544 VerifyOffset(verifier, VT_DETAILS) && 2545 VerifyQuantizationDetails(verifier, details(), details_type()) && 2546 VerifyField<int32_t>(verifier, VT_QUANTIZED_DIMENSION) && 2547 verifier.EndTable(); 2548 } 2549 QuantizationParametersT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2550 void UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2551 static flatbuffers::Offset<QuantizationParameters> Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2552 }; 2553 2554 template<> inline const CustomQuantization *QuantizationParameters::details_as<CustomQuantization>() const { 2555 return details_as_CustomQuantization(); 2556 } 2557 2558 struct QuantizationParametersBuilder { 2559 flatbuffers::FlatBufferBuilder &fbb_; 2560 flatbuffers::uoffset_t start_; 2561 void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) { 2562 fbb_.AddOffset(QuantizationParameters::VT_MIN, min); 2563 } 2564 void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) { 2565 fbb_.AddOffset(QuantizationParameters::VT_MAX, max); 2566 } 2567 void add_scale(flatbuffers::Offset<flatbuffers::Vector<float>> scale) { 2568 fbb_.AddOffset(QuantizationParameters::VT_SCALE, scale); 2569 } 2570 void add_zero_point(flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point) { 2571 fbb_.AddOffset(QuantizationParameters::VT_ZERO_POINT, zero_point); 2572 } 2573 void add_details_type(QuantizationDetails details_type) { 2574 fbb_.AddElement<uint8_t>(QuantizationParameters::VT_DETAILS_TYPE, static_cast<uint8_t>(details_type), 0); 2575 } 2576 void add_details(flatbuffers::Offset<void> details) { 2577 fbb_.AddOffset(QuantizationParameters::VT_DETAILS, details); 2578 } 2579 void add_quantized_dimension(int32_t quantized_dimension) { 2580 fbb_.AddElement<int32_t>(QuantizationParameters::VT_QUANTIZED_DIMENSION, quantized_dimension, 0); 2581 } 2582 explicit QuantizationParametersBuilder(flatbuffers::FlatBufferBuilder &_fbb) 2583 : fbb_(_fbb) { 2584 start_ = fbb_.StartTable(); 2585 } 2586 QuantizationParametersBuilder &operator=(const QuantizationParametersBuilder &); 2587 flatbuffers::Offset<QuantizationParameters> Finish() { 2588 const auto end = fbb_.EndTable(start_); 2589 auto o = flatbuffers::Offset<QuantizationParameters>(end); 2590 return o; 2591 } 2592 }; 2593 2594 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters( 2595 flatbuffers::FlatBufferBuilder &_fbb, 2596 flatbuffers::Offset<flatbuffers::Vector<float>> min = 0, 2597 flatbuffers::Offset<flatbuffers::Vector<float>> max = 0, 2598 flatbuffers::Offset<flatbuffers::Vector<float>> scale = 0, 2599 flatbuffers::Offset<flatbuffers::Vector<int64_t>> zero_point = 0, 2600 QuantizationDetails details_type = QuantizationDetails_NONE, 2601 flatbuffers::Offset<void> details = 0, 2602 int32_t quantized_dimension = 0) { 2603 QuantizationParametersBuilder builder_(_fbb); 2604 builder_.add_quantized_dimension(quantized_dimension); 2605 builder_.add_details(details); 2606 builder_.add_zero_point(zero_point); 2607 builder_.add_scale(scale); 2608 builder_.add_max(max); 2609 builder_.add_min(min); 2610 builder_.add_details_type(details_type); 2611 return builder_.Finish(); 2612 } 2613 2614 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParametersDirect( 2615 flatbuffers::FlatBufferBuilder &_fbb, 2616 const std::vector<float> *min = nullptr, 2617 const std::vector<float> *max = nullptr, 2618 const std::vector<float> *scale = nullptr, 2619 const std::vector<int64_t> *zero_point = nullptr, 2620 QuantizationDetails details_type = QuantizationDetails_NONE, 2621 flatbuffers::Offset<void> details = 0, 2622 int32_t quantized_dimension = 0) { 2623 return tflite::CreateQuantizationParameters( 2624 _fbb, 2625 min ? _fbb.CreateVector<float>(*min) : 0, 2626 max ? _fbb.CreateVector<float>(*max) : 0, 2627 scale ? _fbb.CreateVector<float>(*scale) : 0, 2628 zero_point ? _fbb.CreateVector<int64_t>(*zero_point) : 0, 2629 details_type, 2630 details, 2631 quantized_dimension); 2632 } 2633 2634 flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2635 2636 struct TensorT : public flatbuffers::NativeTable { 2637 typedef Tensor TableType; 2638 std::vector<int32_t> shape; 2639 TensorType type; 2640 uint32_t buffer; 2641 std::string name; 2642 std::unique_ptr<QuantizationParametersT> quantization; 2643 bool is_variable; 2644 TensorT() 2645 : type(TensorType_FLOAT32), 2646 buffer(0), 2647 is_variable(false) { 2648 } 2649 }; 2650 2651 struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 2652 typedef TensorT NativeTableType; 2653 enum { 2654 VT_SHAPE = 4, 2655 VT_TYPE = 6, 2656 VT_BUFFER = 8, 2657 VT_NAME = 10, 2658 VT_QUANTIZATION = 12, 2659 VT_IS_VARIABLE = 14 2660 }; 2661 const flatbuffers::Vector<int32_t> *shape() const { 2662 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE); 2663 } 2664 TensorType type() const { 2665 return static_cast<TensorType>(GetField<int8_t>(VT_TYPE, 0)); 2666 } 2667 uint32_t buffer() const { 2668 return GetField<uint32_t>(VT_BUFFER, 0); 2669 } 2670 const flatbuffers::String *name() const { 2671 return GetPointer<const flatbuffers::String *>(VT_NAME); 2672 } 2673 const QuantizationParameters *quantization() const { 2674 return GetPointer<const QuantizationParameters *>(VT_QUANTIZATION); 2675 } 2676 bool is_variable() const { 2677 return GetField<uint8_t>(VT_IS_VARIABLE, 0) != 0; 2678 } 2679 bool Verify(flatbuffers::Verifier &verifier) const { 2680 return VerifyTableStart(verifier) && 2681 VerifyOffset(verifier, VT_SHAPE) && 2682 verifier.VerifyVector(shape()) && 2683 VerifyField<int8_t>(verifier, VT_TYPE) && 2684 VerifyField<uint32_t>(verifier, VT_BUFFER) && 2685 VerifyOffset(verifier, VT_NAME) && 2686 verifier.VerifyString(name()) && 2687 VerifyOffset(verifier, VT_QUANTIZATION) && 2688 verifier.VerifyTable(quantization()) && 2689 VerifyField<uint8_t>(verifier, VT_IS_VARIABLE) && 2690 verifier.EndTable(); 2691 } 2692 TensorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2693 void UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2694 static flatbuffers::Offset<Tensor> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2695 }; 2696 2697 struct TensorBuilder { 2698 flatbuffers::FlatBufferBuilder &fbb_; 2699 flatbuffers::uoffset_t start_; 2700 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) { 2701 fbb_.AddOffset(Tensor::VT_SHAPE, shape); 2702 } 2703 void add_type(TensorType type) { 2704 fbb_.AddElement<int8_t>(Tensor::VT_TYPE, static_cast<int8_t>(type), 0); 2705 } 2706 void add_buffer(uint32_t buffer) { 2707 fbb_.AddElement<uint32_t>(Tensor::VT_BUFFER, buffer, 0); 2708 } 2709 void add_name(flatbuffers::Offset<flatbuffers::String> name) { 2710 fbb_.AddOffset(Tensor::VT_NAME, name); 2711 } 2712 void add_quantization(flatbuffers::Offset<QuantizationParameters> quantization) { 2713 fbb_.AddOffset(Tensor::VT_QUANTIZATION, quantization); 2714 } 2715 void add_is_variable(bool is_variable) { 2716 fbb_.AddElement<uint8_t>(Tensor::VT_IS_VARIABLE, static_cast<uint8_t>(is_variable), 0); 2717 } 2718 explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) 2719 : fbb_(_fbb) { 2720 start_ = fbb_.StartTable(); 2721 } 2722 TensorBuilder &operator=(const TensorBuilder &); 2723 flatbuffers::Offset<Tensor> Finish() { 2724 const auto end = fbb_.EndTable(start_); 2725 auto o = flatbuffers::Offset<Tensor>(end); 2726 return o; 2727 } 2728 }; 2729 2730 inline flatbuffers::Offset<Tensor> CreateTensor( 2731 flatbuffers::FlatBufferBuilder &_fbb, 2732 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0, 2733 TensorType type = TensorType_FLOAT32, 2734 uint32_t buffer = 0, 2735 flatbuffers::Offset<flatbuffers::String> name = 0, 2736 flatbuffers::Offset<QuantizationParameters> quantization = 0, 2737 bool is_variable = false) { 2738 TensorBuilder builder_(_fbb); 2739 builder_.add_quantization(quantization); 2740 builder_.add_name(name); 2741 builder_.add_buffer(buffer); 2742 builder_.add_shape(shape); 2743 builder_.add_is_variable(is_variable); 2744 builder_.add_type(type); 2745 return builder_.Finish(); 2746 } 2747 2748 inline flatbuffers::Offset<Tensor> CreateTensorDirect( 2749 flatbuffers::FlatBufferBuilder &_fbb, 2750 const std::vector<int32_t> *shape = nullptr, 2751 TensorType type = TensorType_FLOAT32, 2752 uint32_t buffer = 0, 2753 const char *name = nullptr, 2754 flatbuffers::Offset<QuantizationParameters> quantization = 0, 2755 bool is_variable = false) { 2756 return tflite::CreateTensor( 2757 _fbb, 2758 shape ? _fbb.CreateVector<int32_t>(*shape) : 0, 2759 type, 2760 buffer, 2761 name ? _fbb.CreateString(name) : 0, 2762 quantization, 2763 is_variable); 2764 } 2765 2766 flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2767 2768 struct Conv2DOptionsT : public flatbuffers::NativeTable { 2769 typedef Conv2DOptions TableType; 2770 Padding padding; 2771 int32_t stride_w; 2772 int32_t stride_h; 2773 ActivationFunctionType fused_activation_function; 2774 int32_t dilation_w_factor; 2775 int32_t dilation_h_factor; 2776 Conv2DOptionsT() 2777 : padding(Padding_SAME), 2778 stride_w(0), 2779 stride_h(0), 2780 fused_activation_function(ActivationFunctionType_NONE), 2781 dilation_w_factor(1), 2782 dilation_h_factor(1) { 2783 } 2784 }; 2785 2786 struct Conv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 2787 typedef Conv2DOptionsT NativeTableType; 2788 enum { 2789 VT_PADDING = 4, 2790 VT_STRIDE_W = 6, 2791 VT_STRIDE_H = 8, 2792 VT_FUSED_ACTIVATION_FUNCTION = 10, 2793 VT_DILATION_W_FACTOR = 12, 2794 VT_DILATION_H_FACTOR = 14 2795 }; 2796 Padding padding() const { 2797 return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); 2798 } 2799 int32_t stride_w() const { 2800 return GetField<int32_t>(VT_STRIDE_W, 0); 2801 } 2802 int32_t stride_h() const { 2803 return GetField<int32_t>(VT_STRIDE_H, 0); 2804 } 2805 ActivationFunctionType fused_activation_function() const { 2806 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 2807 } 2808 int32_t dilation_w_factor() const { 2809 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); 2810 } 2811 int32_t dilation_h_factor() const { 2812 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); 2813 } 2814 bool Verify(flatbuffers::Verifier &verifier) const { 2815 return VerifyTableStart(verifier) && 2816 VerifyField<int8_t>(verifier, VT_PADDING) && 2817 VerifyField<int32_t>(verifier, VT_STRIDE_W) && 2818 VerifyField<int32_t>(verifier, VT_STRIDE_H) && 2819 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 2820 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) && 2821 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && 2822 verifier.EndTable(); 2823 } 2824 Conv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2825 void UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2826 static flatbuffers::Offset<Conv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2827 }; 2828 2829 struct Conv2DOptionsBuilder { 2830 flatbuffers::FlatBufferBuilder &fbb_; 2831 flatbuffers::uoffset_t start_; 2832 void add_padding(Padding padding) { 2833 fbb_.AddElement<int8_t>(Conv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0); 2834 } 2835 void add_stride_w(int32_t stride_w) { 2836 fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_W, stride_w, 0); 2837 } 2838 void add_stride_h(int32_t stride_h) { 2839 fbb_.AddElement<int32_t>(Conv2DOptions::VT_STRIDE_H, stride_h, 0); 2840 } 2841 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 2842 fbb_.AddElement<int8_t>(Conv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 2843 } 2844 void add_dilation_w_factor(int32_t dilation_w_factor) { 2845 fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1); 2846 } 2847 void add_dilation_h_factor(int32_t dilation_h_factor) { 2848 fbb_.AddElement<int32_t>(Conv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1); 2849 } 2850 explicit Conv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 2851 : fbb_(_fbb) { 2852 start_ = fbb_.StartTable(); 2853 } 2854 Conv2DOptionsBuilder &operator=(const Conv2DOptionsBuilder &); 2855 flatbuffers::Offset<Conv2DOptions> Finish() { 2856 const auto end = fbb_.EndTable(start_); 2857 auto o = flatbuffers::Offset<Conv2DOptions>(end); 2858 return o; 2859 } 2860 }; 2861 2862 inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions( 2863 flatbuffers::FlatBufferBuilder &_fbb, 2864 Padding padding = Padding_SAME, 2865 int32_t stride_w = 0, 2866 int32_t stride_h = 0, 2867 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, 2868 int32_t dilation_w_factor = 1, 2869 int32_t dilation_h_factor = 1) { 2870 Conv2DOptionsBuilder builder_(_fbb); 2871 builder_.add_dilation_h_factor(dilation_h_factor); 2872 builder_.add_dilation_w_factor(dilation_w_factor); 2873 builder_.add_stride_h(stride_h); 2874 builder_.add_stride_w(stride_w); 2875 builder_.add_fused_activation_function(fused_activation_function); 2876 builder_.add_padding(padding); 2877 return builder_.Finish(); 2878 } 2879 2880 flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2881 2882 struct Pool2DOptionsT : public flatbuffers::NativeTable { 2883 typedef Pool2DOptions TableType; 2884 Padding padding; 2885 int32_t stride_w; 2886 int32_t stride_h; 2887 int32_t filter_width; 2888 int32_t filter_height; 2889 ActivationFunctionType fused_activation_function; 2890 Pool2DOptionsT() 2891 : padding(Padding_SAME), 2892 stride_w(0), 2893 stride_h(0), 2894 filter_width(0), 2895 filter_height(0), 2896 fused_activation_function(ActivationFunctionType_NONE) { 2897 } 2898 }; 2899 2900 struct Pool2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 2901 typedef Pool2DOptionsT NativeTableType; 2902 enum { 2903 VT_PADDING = 4, 2904 VT_STRIDE_W = 6, 2905 VT_STRIDE_H = 8, 2906 VT_FILTER_WIDTH = 10, 2907 VT_FILTER_HEIGHT = 12, 2908 VT_FUSED_ACTIVATION_FUNCTION = 14 2909 }; 2910 Padding padding() const { 2911 return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); 2912 } 2913 int32_t stride_w() const { 2914 return GetField<int32_t>(VT_STRIDE_W, 0); 2915 } 2916 int32_t stride_h() const { 2917 return GetField<int32_t>(VT_STRIDE_H, 0); 2918 } 2919 int32_t filter_width() const { 2920 return GetField<int32_t>(VT_FILTER_WIDTH, 0); 2921 } 2922 int32_t filter_height() const { 2923 return GetField<int32_t>(VT_FILTER_HEIGHT, 0); 2924 } 2925 ActivationFunctionType fused_activation_function() const { 2926 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 2927 } 2928 bool Verify(flatbuffers::Verifier &verifier) const { 2929 return VerifyTableStart(verifier) && 2930 VerifyField<int8_t>(verifier, VT_PADDING) && 2931 VerifyField<int32_t>(verifier, VT_STRIDE_W) && 2932 VerifyField<int32_t>(verifier, VT_STRIDE_H) && 2933 VerifyField<int32_t>(verifier, VT_FILTER_WIDTH) && 2934 VerifyField<int32_t>(verifier, VT_FILTER_HEIGHT) && 2935 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 2936 verifier.EndTable(); 2937 } 2938 Pool2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2939 void UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 2940 static flatbuffers::Offset<Pool2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2941 }; 2942 2943 struct Pool2DOptionsBuilder { 2944 flatbuffers::FlatBufferBuilder &fbb_; 2945 flatbuffers::uoffset_t start_; 2946 void add_padding(Padding padding) { 2947 fbb_.AddElement<int8_t>(Pool2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0); 2948 } 2949 void add_stride_w(int32_t stride_w) { 2950 fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_W, stride_w, 0); 2951 } 2952 void add_stride_h(int32_t stride_h) { 2953 fbb_.AddElement<int32_t>(Pool2DOptions::VT_STRIDE_H, stride_h, 0); 2954 } 2955 void add_filter_width(int32_t filter_width) { 2956 fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_WIDTH, filter_width, 0); 2957 } 2958 void add_filter_height(int32_t filter_height) { 2959 fbb_.AddElement<int32_t>(Pool2DOptions::VT_FILTER_HEIGHT, filter_height, 0); 2960 } 2961 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 2962 fbb_.AddElement<int8_t>(Pool2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 2963 } 2964 explicit Pool2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 2965 : fbb_(_fbb) { 2966 start_ = fbb_.StartTable(); 2967 } 2968 Pool2DOptionsBuilder &operator=(const Pool2DOptionsBuilder &); 2969 flatbuffers::Offset<Pool2DOptions> Finish() { 2970 const auto end = fbb_.EndTable(start_); 2971 auto o = flatbuffers::Offset<Pool2DOptions>(end); 2972 return o; 2973 } 2974 }; 2975 2976 inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions( 2977 flatbuffers::FlatBufferBuilder &_fbb, 2978 Padding padding = Padding_SAME, 2979 int32_t stride_w = 0, 2980 int32_t stride_h = 0, 2981 int32_t filter_width = 0, 2982 int32_t filter_height = 0, 2983 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 2984 Pool2DOptionsBuilder builder_(_fbb); 2985 builder_.add_filter_height(filter_height); 2986 builder_.add_filter_width(filter_width); 2987 builder_.add_stride_h(stride_h); 2988 builder_.add_stride_w(stride_w); 2989 builder_.add_fused_activation_function(fused_activation_function); 2990 builder_.add_padding(padding); 2991 return builder_.Finish(); 2992 } 2993 2994 flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 2995 2996 struct DepthwiseConv2DOptionsT : public flatbuffers::NativeTable { 2997 typedef DepthwiseConv2DOptions TableType; 2998 Padding padding; 2999 int32_t stride_w; 3000 int32_t stride_h; 3001 int32_t depth_multiplier; 3002 ActivationFunctionType fused_activation_function; 3003 int32_t dilation_w_factor; 3004 int32_t dilation_h_factor; 3005 DepthwiseConv2DOptionsT() 3006 : padding(Padding_SAME), 3007 stride_w(0), 3008 stride_h(0), 3009 depth_multiplier(0), 3010 fused_activation_function(ActivationFunctionType_NONE), 3011 dilation_w_factor(1), 3012 dilation_h_factor(1) { 3013 } 3014 }; 3015 3016 struct DepthwiseConv2DOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3017 typedef DepthwiseConv2DOptionsT NativeTableType; 3018 enum { 3019 VT_PADDING = 4, 3020 VT_STRIDE_W = 6, 3021 VT_STRIDE_H = 8, 3022 VT_DEPTH_MULTIPLIER = 10, 3023 VT_FUSED_ACTIVATION_FUNCTION = 12, 3024 VT_DILATION_W_FACTOR = 14, 3025 VT_DILATION_H_FACTOR = 16 3026 }; 3027 Padding padding() const { 3028 return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); 3029 } 3030 int32_t stride_w() const { 3031 return GetField<int32_t>(VT_STRIDE_W, 0); 3032 } 3033 int32_t stride_h() const { 3034 return GetField<int32_t>(VT_STRIDE_H, 0); 3035 } 3036 int32_t depth_multiplier() const { 3037 return GetField<int32_t>(VT_DEPTH_MULTIPLIER, 0); 3038 } 3039 ActivationFunctionType fused_activation_function() const { 3040 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3041 } 3042 int32_t dilation_w_factor() const { 3043 return GetField<int32_t>(VT_DILATION_W_FACTOR, 1); 3044 } 3045 int32_t dilation_h_factor() const { 3046 return GetField<int32_t>(VT_DILATION_H_FACTOR, 1); 3047 } 3048 bool Verify(flatbuffers::Verifier &verifier) const { 3049 return VerifyTableStart(verifier) && 3050 VerifyField<int8_t>(verifier, VT_PADDING) && 3051 VerifyField<int32_t>(verifier, VT_STRIDE_W) && 3052 VerifyField<int32_t>(verifier, VT_STRIDE_H) && 3053 VerifyField<int32_t>(verifier, VT_DEPTH_MULTIPLIER) && 3054 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3055 VerifyField<int32_t>(verifier, VT_DILATION_W_FACTOR) && 3056 VerifyField<int32_t>(verifier, VT_DILATION_H_FACTOR) && 3057 verifier.EndTable(); 3058 } 3059 DepthwiseConv2DOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3060 void UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3061 static flatbuffers::Offset<DepthwiseConv2DOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3062 }; 3063 3064 struct DepthwiseConv2DOptionsBuilder { 3065 flatbuffers::FlatBufferBuilder &fbb_; 3066 flatbuffers::uoffset_t start_; 3067 void add_padding(Padding padding) { 3068 fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_PADDING, static_cast<int8_t>(padding), 0); 3069 } 3070 void add_stride_w(int32_t stride_w) { 3071 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_W, stride_w, 0); 3072 } 3073 void add_stride_h(int32_t stride_h) { 3074 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_STRIDE_H, stride_h, 0); 3075 } 3076 void add_depth_multiplier(int32_t depth_multiplier) { 3077 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DEPTH_MULTIPLIER, depth_multiplier, 0); 3078 } 3079 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3080 fbb_.AddElement<int8_t>(DepthwiseConv2DOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3081 } 3082 void add_dilation_w_factor(int32_t dilation_w_factor) { 3083 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_W_FACTOR, dilation_w_factor, 1); 3084 } 3085 void add_dilation_h_factor(int32_t dilation_h_factor) { 3086 fbb_.AddElement<int32_t>(DepthwiseConv2DOptions::VT_DILATION_H_FACTOR, dilation_h_factor, 1); 3087 } 3088 explicit DepthwiseConv2DOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3089 : fbb_(_fbb) { 3090 start_ = fbb_.StartTable(); 3091 } 3092 DepthwiseConv2DOptionsBuilder &operator=(const DepthwiseConv2DOptionsBuilder &); 3093 flatbuffers::Offset<DepthwiseConv2DOptions> Finish() { 3094 const auto end = fbb_.EndTable(start_); 3095 auto o = flatbuffers::Offset<DepthwiseConv2DOptions>(end); 3096 return o; 3097 } 3098 }; 3099 3100 inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions( 3101 flatbuffers::FlatBufferBuilder &_fbb, 3102 Padding padding = Padding_SAME, 3103 int32_t stride_w = 0, 3104 int32_t stride_h = 0, 3105 int32_t depth_multiplier = 0, 3106 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, 3107 int32_t dilation_w_factor = 1, 3108 int32_t dilation_h_factor = 1) { 3109 DepthwiseConv2DOptionsBuilder builder_(_fbb); 3110 builder_.add_dilation_h_factor(dilation_h_factor); 3111 builder_.add_dilation_w_factor(dilation_w_factor); 3112 builder_.add_depth_multiplier(depth_multiplier); 3113 builder_.add_stride_h(stride_h); 3114 builder_.add_stride_w(stride_w); 3115 builder_.add_fused_activation_function(fused_activation_function); 3116 builder_.add_padding(padding); 3117 return builder_.Finish(); 3118 } 3119 3120 flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3121 3122 struct ConcatEmbeddingsOptionsT : public flatbuffers::NativeTable { 3123 typedef ConcatEmbeddingsOptions TableType; 3124 int32_t num_channels; 3125 std::vector<int32_t> num_columns_per_channel; 3126 std::vector<int32_t> embedding_dim_per_channel; 3127 ConcatEmbeddingsOptionsT() 3128 : num_channels(0) { 3129 } 3130 }; 3131 3132 struct ConcatEmbeddingsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3133 typedef ConcatEmbeddingsOptionsT NativeTableType; 3134 enum { 3135 VT_NUM_CHANNELS = 4, 3136 VT_NUM_COLUMNS_PER_CHANNEL = 6, 3137 VT_EMBEDDING_DIM_PER_CHANNEL = 8 3138 }; 3139 int32_t num_channels() const { 3140 return GetField<int32_t>(VT_NUM_CHANNELS, 0); 3141 } 3142 const flatbuffers::Vector<int32_t> *num_columns_per_channel() const { 3143 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NUM_COLUMNS_PER_CHANNEL); 3144 } 3145 const flatbuffers::Vector<int32_t> *embedding_dim_per_channel() const { 3146 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_EMBEDDING_DIM_PER_CHANNEL); 3147 } 3148 bool Verify(flatbuffers::Verifier &verifier) const { 3149 return VerifyTableStart(verifier) && 3150 VerifyField<int32_t>(verifier, VT_NUM_CHANNELS) && 3151 VerifyOffset(verifier, VT_NUM_COLUMNS_PER_CHANNEL) && 3152 verifier.VerifyVector(num_columns_per_channel()) && 3153 VerifyOffset(verifier, VT_EMBEDDING_DIM_PER_CHANNEL) && 3154 verifier.VerifyVector(embedding_dim_per_channel()) && 3155 verifier.EndTable(); 3156 } 3157 ConcatEmbeddingsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3158 void UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3159 static flatbuffers::Offset<ConcatEmbeddingsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3160 }; 3161 3162 struct ConcatEmbeddingsOptionsBuilder { 3163 flatbuffers::FlatBufferBuilder &fbb_; 3164 flatbuffers::uoffset_t start_; 3165 void add_num_channels(int32_t num_channels) { 3166 fbb_.AddElement<int32_t>(ConcatEmbeddingsOptions::VT_NUM_CHANNELS, num_channels, 0); 3167 } 3168 void add_num_columns_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel) { 3169 fbb_.AddOffset(ConcatEmbeddingsOptions::VT_NUM_COLUMNS_PER_CHANNEL, num_columns_per_channel); 3170 } 3171 void add_embedding_dim_per_channel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel) { 3172 fbb_.AddOffset(ConcatEmbeddingsOptions::VT_EMBEDDING_DIM_PER_CHANNEL, embedding_dim_per_channel); 3173 } 3174 explicit ConcatEmbeddingsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3175 : fbb_(_fbb) { 3176 start_ = fbb_.StartTable(); 3177 } 3178 ConcatEmbeddingsOptionsBuilder &operator=(const ConcatEmbeddingsOptionsBuilder &); 3179 flatbuffers::Offset<ConcatEmbeddingsOptions> Finish() { 3180 const auto end = fbb_.EndTable(start_); 3181 auto o = flatbuffers::Offset<ConcatEmbeddingsOptions>(end); 3182 return o; 3183 } 3184 }; 3185 3186 inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions( 3187 flatbuffers::FlatBufferBuilder &_fbb, 3188 int32_t num_channels = 0, 3189 flatbuffers::Offset<flatbuffers::Vector<int32_t>> num_columns_per_channel = 0, 3190 flatbuffers::Offset<flatbuffers::Vector<int32_t>> embedding_dim_per_channel = 0) { 3191 ConcatEmbeddingsOptionsBuilder builder_(_fbb); 3192 builder_.add_embedding_dim_per_channel(embedding_dim_per_channel); 3193 builder_.add_num_columns_per_channel(num_columns_per_channel); 3194 builder_.add_num_channels(num_channels); 3195 return builder_.Finish(); 3196 } 3197 3198 inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptionsDirect( 3199 flatbuffers::FlatBufferBuilder &_fbb, 3200 int32_t num_channels = 0, 3201 const std::vector<int32_t> *num_columns_per_channel = nullptr, 3202 const std::vector<int32_t> *embedding_dim_per_channel = nullptr) { 3203 return tflite::CreateConcatEmbeddingsOptions( 3204 _fbb, 3205 num_channels, 3206 num_columns_per_channel ? _fbb.CreateVector<int32_t>(*num_columns_per_channel) : 0, 3207 embedding_dim_per_channel ? _fbb.CreateVector<int32_t>(*embedding_dim_per_channel) : 0); 3208 } 3209 3210 flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3211 3212 struct LSHProjectionOptionsT : public flatbuffers::NativeTable { 3213 typedef LSHProjectionOptions TableType; 3214 LSHProjectionType type; 3215 LSHProjectionOptionsT() 3216 : type(LSHProjectionType_UNKNOWN) { 3217 } 3218 }; 3219 3220 struct LSHProjectionOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3221 typedef LSHProjectionOptionsT NativeTableType; 3222 enum { 3223 VT_TYPE = 4 3224 }; 3225 LSHProjectionType type() const { 3226 return static_cast<LSHProjectionType>(GetField<int8_t>(VT_TYPE, 0)); 3227 } 3228 bool Verify(flatbuffers::Verifier &verifier) const { 3229 return VerifyTableStart(verifier) && 3230 VerifyField<int8_t>(verifier, VT_TYPE) && 3231 verifier.EndTable(); 3232 } 3233 LSHProjectionOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3234 void UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3235 static flatbuffers::Offset<LSHProjectionOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3236 }; 3237 3238 struct LSHProjectionOptionsBuilder { 3239 flatbuffers::FlatBufferBuilder &fbb_; 3240 flatbuffers::uoffset_t start_; 3241 void add_type(LSHProjectionType type) { 3242 fbb_.AddElement<int8_t>(LSHProjectionOptions::VT_TYPE, static_cast<int8_t>(type), 0); 3243 } 3244 explicit LSHProjectionOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3245 : fbb_(_fbb) { 3246 start_ = fbb_.StartTable(); 3247 } 3248 LSHProjectionOptionsBuilder &operator=(const LSHProjectionOptionsBuilder &); 3249 flatbuffers::Offset<LSHProjectionOptions> Finish() { 3250 const auto end = fbb_.EndTable(start_); 3251 auto o = flatbuffers::Offset<LSHProjectionOptions>(end); 3252 return o; 3253 } 3254 }; 3255 3256 inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions( 3257 flatbuffers::FlatBufferBuilder &_fbb, 3258 LSHProjectionType type = LSHProjectionType_UNKNOWN) { 3259 LSHProjectionOptionsBuilder builder_(_fbb); 3260 builder_.add_type(type); 3261 return builder_.Finish(); 3262 } 3263 3264 flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3265 3266 struct SVDFOptionsT : public flatbuffers::NativeTable { 3267 typedef SVDFOptions TableType; 3268 int32_t rank; 3269 ActivationFunctionType fused_activation_function; 3270 SVDFOptionsT() 3271 : rank(0), 3272 fused_activation_function(ActivationFunctionType_NONE) { 3273 } 3274 }; 3275 3276 struct SVDFOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3277 typedef SVDFOptionsT NativeTableType; 3278 enum { 3279 VT_RANK = 4, 3280 VT_FUSED_ACTIVATION_FUNCTION = 6 3281 }; 3282 int32_t rank() const { 3283 return GetField<int32_t>(VT_RANK, 0); 3284 } 3285 ActivationFunctionType fused_activation_function() const { 3286 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3287 } 3288 bool Verify(flatbuffers::Verifier &verifier) const { 3289 return VerifyTableStart(verifier) && 3290 VerifyField<int32_t>(verifier, VT_RANK) && 3291 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3292 verifier.EndTable(); 3293 } 3294 SVDFOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3295 void UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3296 static flatbuffers::Offset<SVDFOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3297 }; 3298 3299 struct SVDFOptionsBuilder { 3300 flatbuffers::FlatBufferBuilder &fbb_; 3301 flatbuffers::uoffset_t start_; 3302 void add_rank(int32_t rank) { 3303 fbb_.AddElement<int32_t>(SVDFOptions::VT_RANK, rank, 0); 3304 } 3305 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3306 fbb_.AddElement<int8_t>(SVDFOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3307 } 3308 explicit SVDFOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3309 : fbb_(_fbb) { 3310 start_ = fbb_.StartTable(); 3311 } 3312 SVDFOptionsBuilder &operator=(const SVDFOptionsBuilder &); 3313 flatbuffers::Offset<SVDFOptions> Finish() { 3314 const auto end = fbb_.EndTable(start_); 3315 auto o = flatbuffers::Offset<SVDFOptions>(end); 3316 return o; 3317 } 3318 }; 3319 3320 inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions( 3321 flatbuffers::FlatBufferBuilder &_fbb, 3322 int32_t rank = 0, 3323 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 3324 SVDFOptionsBuilder builder_(_fbb); 3325 builder_.add_rank(rank); 3326 builder_.add_fused_activation_function(fused_activation_function); 3327 return builder_.Finish(); 3328 } 3329 3330 flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3331 3332 struct RNNOptionsT : public flatbuffers::NativeTable { 3333 typedef RNNOptions TableType; 3334 ActivationFunctionType fused_activation_function; 3335 RNNOptionsT() 3336 : fused_activation_function(ActivationFunctionType_NONE) { 3337 } 3338 }; 3339 3340 struct RNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3341 typedef RNNOptionsT NativeTableType; 3342 enum { 3343 VT_FUSED_ACTIVATION_FUNCTION = 4 3344 }; 3345 ActivationFunctionType fused_activation_function() const { 3346 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3347 } 3348 bool Verify(flatbuffers::Verifier &verifier) const { 3349 return VerifyTableStart(verifier) && 3350 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3351 verifier.EndTable(); 3352 } 3353 RNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3354 void UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3355 static flatbuffers::Offset<RNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3356 }; 3357 3358 struct RNNOptionsBuilder { 3359 flatbuffers::FlatBufferBuilder &fbb_; 3360 flatbuffers::uoffset_t start_; 3361 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3362 fbb_.AddElement<int8_t>(RNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3363 } 3364 explicit RNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3365 : fbb_(_fbb) { 3366 start_ = fbb_.StartTable(); 3367 } 3368 RNNOptionsBuilder &operator=(const RNNOptionsBuilder &); 3369 flatbuffers::Offset<RNNOptions> Finish() { 3370 const auto end = fbb_.EndTable(start_); 3371 auto o = flatbuffers::Offset<RNNOptions>(end); 3372 return o; 3373 } 3374 }; 3375 3376 inline flatbuffers::Offset<RNNOptions> CreateRNNOptions( 3377 flatbuffers::FlatBufferBuilder &_fbb, 3378 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 3379 RNNOptionsBuilder builder_(_fbb); 3380 builder_.add_fused_activation_function(fused_activation_function); 3381 return builder_.Finish(); 3382 } 3383 3384 flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3385 3386 struct SequenceRNNOptionsT : public flatbuffers::NativeTable { 3387 typedef SequenceRNNOptions TableType; 3388 bool time_major; 3389 ActivationFunctionType fused_activation_function; 3390 SequenceRNNOptionsT() 3391 : time_major(false), 3392 fused_activation_function(ActivationFunctionType_NONE) { 3393 } 3394 }; 3395 3396 struct SequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3397 typedef SequenceRNNOptionsT NativeTableType; 3398 enum { 3399 VT_TIME_MAJOR = 4, 3400 VT_FUSED_ACTIVATION_FUNCTION = 6 3401 }; 3402 bool time_major() const { 3403 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; 3404 } 3405 ActivationFunctionType fused_activation_function() const { 3406 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3407 } 3408 bool Verify(flatbuffers::Verifier &verifier) const { 3409 return VerifyTableStart(verifier) && 3410 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) && 3411 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3412 verifier.EndTable(); 3413 } 3414 SequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3415 void UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3416 static flatbuffers::Offset<SequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3417 }; 3418 3419 struct SequenceRNNOptionsBuilder { 3420 flatbuffers::FlatBufferBuilder &fbb_; 3421 flatbuffers::uoffset_t start_; 3422 void add_time_major(bool time_major) { 3423 fbb_.AddElement<uint8_t>(SequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0); 3424 } 3425 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3426 fbb_.AddElement<int8_t>(SequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3427 } 3428 explicit SequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3429 : fbb_(_fbb) { 3430 start_ = fbb_.StartTable(); 3431 } 3432 SequenceRNNOptionsBuilder &operator=(const SequenceRNNOptionsBuilder &); 3433 flatbuffers::Offset<SequenceRNNOptions> Finish() { 3434 const auto end = fbb_.EndTable(start_); 3435 auto o = flatbuffers::Offset<SequenceRNNOptions>(end); 3436 return o; 3437 } 3438 }; 3439 3440 inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions( 3441 flatbuffers::FlatBufferBuilder &_fbb, 3442 bool time_major = false, 3443 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 3444 SequenceRNNOptionsBuilder builder_(_fbb); 3445 builder_.add_fused_activation_function(fused_activation_function); 3446 builder_.add_time_major(time_major); 3447 return builder_.Finish(); 3448 } 3449 3450 flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3451 3452 struct BidirectionalSequenceRNNOptionsT : public flatbuffers::NativeTable { 3453 typedef BidirectionalSequenceRNNOptions TableType; 3454 bool time_major; 3455 ActivationFunctionType fused_activation_function; 3456 bool merge_outputs; 3457 BidirectionalSequenceRNNOptionsT() 3458 : time_major(false), 3459 fused_activation_function(ActivationFunctionType_NONE), 3460 merge_outputs(false) { 3461 } 3462 }; 3463 3464 struct BidirectionalSequenceRNNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3465 typedef BidirectionalSequenceRNNOptionsT NativeTableType; 3466 enum { 3467 VT_TIME_MAJOR = 4, 3468 VT_FUSED_ACTIVATION_FUNCTION = 6, 3469 VT_MERGE_OUTPUTS = 8 3470 }; 3471 bool time_major() const { 3472 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; 3473 } 3474 ActivationFunctionType fused_activation_function() const { 3475 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3476 } 3477 bool merge_outputs() const { 3478 return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; 3479 } 3480 bool Verify(flatbuffers::Verifier &verifier) const { 3481 return VerifyTableStart(verifier) && 3482 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) && 3483 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3484 VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) && 3485 verifier.EndTable(); 3486 } 3487 BidirectionalSequenceRNNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3488 void UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3489 static flatbuffers::Offset<BidirectionalSequenceRNNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3490 }; 3491 3492 struct BidirectionalSequenceRNNOptionsBuilder { 3493 flatbuffers::FlatBufferBuilder &fbb_; 3494 flatbuffers::uoffset_t start_; 3495 void add_time_major(bool time_major) { 3496 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0); 3497 } 3498 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3499 fbb_.AddElement<int8_t>(BidirectionalSequenceRNNOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3500 } 3501 void add_merge_outputs(bool merge_outputs) { 3502 fbb_.AddElement<uint8_t>(BidirectionalSequenceRNNOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0); 3503 } 3504 explicit BidirectionalSequenceRNNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3505 : fbb_(_fbb) { 3506 start_ = fbb_.StartTable(); 3507 } 3508 BidirectionalSequenceRNNOptionsBuilder &operator=(const BidirectionalSequenceRNNOptionsBuilder &); 3509 flatbuffers::Offset<BidirectionalSequenceRNNOptions> Finish() { 3510 const auto end = fbb_.EndTable(start_); 3511 auto o = flatbuffers::Offset<BidirectionalSequenceRNNOptions>(end); 3512 return o; 3513 } 3514 }; 3515 3516 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions( 3517 flatbuffers::FlatBufferBuilder &_fbb, 3518 bool time_major = false, 3519 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, 3520 bool merge_outputs = false) { 3521 BidirectionalSequenceRNNOptionsBuilder builder_(_fbb); 3522 builder_.add_merge_outputs(merge_outputs); 3523 builder_.add_fused_activation_function(fused_activation_function); 3524 builder_.add_time_major(time_major); 3525 return builder_.Finish(); 3526 } 3527 3528 flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3529 3530 struct FullyConnectedOptionsT : public flatbuffers::NativeTable { 3531 typedef FullyConnectedOptions TableType; 3532 ActivationFunctionType fused_activation_function; 3533 FullyConnectedOptionsWeightsFormat weights_format; 3534 FullyConnectedOptionsT() 3535 : fused_activation_function(ActivationFunctionType_NONE), 3536 weights_format(FullyConnectedOptionsWeightsFormat_DEFAULT) { 3537 } 3538 }; 3539 3540 struct FullyConnectedOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3541 typedef FullyConnectedOptionsT NativeTableType; 3542 enum { 3543 VT_FUSED_ACTIVATION_FUNCTION = 4, 3544 VT_WEIGHTS_FORMAT = 6 3545 }; 3546 ActivationFunctionType fused_activation_function() const { 3547 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3548 } 3549 FullyConnectedOptionsWeightsFormat weights_format() const { 3550 return static_cast<FullyConnectedOptionsWeightsFormat>(GetField<int8_t>(VT_WEIGHTS_FORMAT, 0)); 3551 } 3552 bool Verify(flatbuffers::Verifier &verifier) const { 3553 return VerifyTableStart(verifier) && 3554 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3555 VerifyField<int8_t>(verifier, VT_WEIGHTS_FORMAT) && 3556 verifier.EndTable(); 3557 } 3558 FullyConnectedOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3559 void UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3560 static flatbuffers::Offset<FullyConnectedOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3561 }; 3562 3563 struct FullyConnectedOptionsBuilder { 3564 flatbuffers::FlatBufferBuilder &fbb_; 3565 flatbuffers::uoffset_t start_; 3566 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3567 fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3568 } 3569 void add_weights_format(FullyConnectedOptionsWeightsFormat weights_format) { 3570 fbb_.AddElement<int8_t>(FullyConnectedOptions::VT_WEIGHTS_FORMAT, static_cast<int8_t>(weights_format), 0); 3571 } 3572 explicit FullyConnectedOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3573 : fbb_(_fbb) { 3574 start_ = fbb_.StartTable(); 3575 } 3576 FullyConnectedOptionsBuilder &operator=(const FullyConnectedOptionsBuilder &); 3577 flatbuffers::Offset<FullyConnectedOptions> Finish() { 3578 const auto end = fbb_.EndTable(start_); 3579 auto o = flatbuffers::Offset<FullyConnectedOptions>(end); 3580 return o; 3581 } 3582 }; 3583 3584 inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions( 3585 flatbuffers::FlatBufferBuilder &_fbb, 3586 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, 3587 FullyConnectedOptionsWeightsFormat weights_format = FullyConnectedOptionsWeightsFormat_DEFAULT) { 3588 FullyConnectedOptionsBuilder builder_(_fbb); 3589 builder_.add_weights_format(weights_format); 3590 builder_.add_fused_activation_function(fused_activation_function); 3591 return builder_.Finish(); 3592 } 3593 3594 flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3595 3596 struct SoftmaxOptionsT : public flatbuffers::NativeTable { 3597 typedef SoftmaxOptions TableType; 3598 float beta; 3599 SoftmaxOptionsT() 3600 : beta(0.0f) { 3601 } 3602 }; 3603 3604 struct SoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3605 typedef SoftmaxOptionsT NativeTableType; 3606 enum { 3607 VT_BETA = 4 3608 }; 3609 float beta() const { 3610 return GetField<float>(VT_BETA, 0.0f); 3611 } 3612 bool Verify(flatbuffers::Verifier &verifier) const { 3613 return VerifyTableStart(verifier) && 3614 VerifyField<float>(verifier, VT_BETA) && 3615 verifier.EndTable(); 3616 } 3617 SoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3618 void UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3619 static flatbuffers::Offset<SoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3620 }; 3621 3622 struct SoftmaxOptionsBuilder { 3623 flatbuffers::FlatBufferBuilder &fbb_; 3624 flatbuffers::uoffset_t start_; 3625 void add_beta(float beta) { 3626 fbb_.AddElement<float>(SoftmaxOptions::VT_BETA, beta, 0.0f); 3627 } 3628 explicit SoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3629 : fbb_(_fbb) { 3630 start_ = fbb_.StartTable(); 3631 } 3632 SoftmaxOptionsBuilder &operator=(const SoftmaxOptionsBuilder &); 3633 flatbuffers::Offset<SoftmaxOptions> Finish() { 3634 const auto end = fbb_.EndTable(start_); 3635 auto o = flatbuffers::Offset<SoftmaxOptions>(end); 3636 return o; 3637 } 3638 }; 3639 3640 inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions( 3641 flatbuffers::FlatBufferBuilder &_fbb, 3642 float beta = 0.0f) { 3643 SoftmaxOptionsBuilder builder_(_fbb); 3644 builder_.add_beta(beta); 3645 return builder_.Finish(); 3646 } 3647 3648 flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3649 3650 struct ConcatenationOptionsT : public flatbuffers::NativeTable { 3651 typedef ConcatenationOptions TableType; 3652 int32_t axis; 3653 ActivationFunctionType fused_activation_function; 3654 ConcatenationOptionsT() 3655 : axis(0), 3656 fused_activation_function(ActivationFunctionType_NONE) { 3657 } 3658 }; 3659 3660 struct ConcatenationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3661 typedef ConcatenationOptionsT NativeTableType; 3662 enum { 3663 VT_AXIS = 4, 3664 VT_FUSED_ACTIVATION_FUNCTION = 6 3665 }; 3666 int32_t axis() const { 3667 return GetField<int32_t>(VT_AXIS, 0); 3668 } 3669 ActivationFunctionType fused_activation_function() const { 3670 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3671 } 3672 bool Verify(flatbuffers::Verifier &verifier) const { 3673 return VerifyTableStart(verifier) && 3674 VerifyField<int32_t>(verifier, VT_AXIS) && 3675 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3676 verifier.EndTable(); 3677 } 3678 ConcatenationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3679 void UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3680 static flatbuffers::Offset<ConcatenationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3681 }; 3682 3683 struct ConcatenationOptionsBuilder { 3684 flatbuffers::FlatBufferBuilder &fbb_; 3685 flatbuffers::uoffset_t start_; 3686 void add_axis(int32_t axis) { 3687 fbb_.AddElement<int32_t>(ConcatenationOptions::VT_AXIS, axis, 0); 3688 } 3689 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3690 fbb_.AddElement<int8_t>(ConcatenationOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3691 } 3692 explicit ConcatenationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3693 : fbb_(_fbb) { 3694 start_ = fbb_.StartTable(); 3695 } 3696 ConcatenationOptionsBuilder &operator=(const ConcatenationOptionsBuilder &); 3697 flatbuffers::Offset<ConcatenationOptions> Finish() { 3698 const auto end = fbb_.EndTable(start_); 3699 auto o = flatbuffers::Offset<ConcatenationOptions>(end); 3700 return o; 3701 } 3702 }; 3703 3704 inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions( 3705 flatbuffers::FlatBufferBuilder &_fbb, 3706 int32_t axis = 0, 3707 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 3708 ConcatenationOptionsBuilder builder_(_fbb); 3709 builder_.add_axis(axis); 3710 builder_.add_fused_activation_function(fused_activation_function); 3711 return builder_.Finish(); 3712 } 3713 3714 flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3715 3716 struct AddOptionsT : public flatbuffers::NativeTable { 3717 typedef AddOptions TableType; 3718 ActivationFunctionType fused_activation_function; 3719 AddOptionsT() 3720 : fused_activation_function(ActivationFunctionType_NONE) { 3721 } 3722 }; 3723 3724 struct AddOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3725 typedef AddOptionsT NativeTableType; 3726 enum { 3727 VT_FUSED_ACTIVATION_FUNCTION = 4 3728 }; 3729 ActivationFunctionType fused_activation_function() const { 3730 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3731 } 3732 bool Verify(flatbuffers::Verifier &verifier) const { 3733 return VerifyTableStart(verifier) && 3734 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3735 verifier.EndTable(); 3736 } 3737 AddOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3738 void UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3739 static flatbuffers::Offset<AddOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3740 }; 3741 3742 struct AddOptionsBuilder { 3743 flatbuffers::FlatBufferBuilder &fbb_; 3744 flatbuffers::uoffset_t start_; 3745 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3746 fbb_.AddElement<int8_t>(AddOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3747 } 3748 explicit AddOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3749 : fbb_(_fbb) { 3750 start_ = fbb_.StartTable(); 3751 } 3752 AddOptionsBuilder &operator=(const AddOptionsBuilder &); 3753 flatbuffers::Offset<AddOptions> Finish() { 3754 const auto end = fbb_.EndTable(start_); 3755 auto o = flatbuffers::Offset<AddOptions>(end); 3756 return o; 3757 } 3758 }; 3759 3760 inline flatbuffers::Offset<AddOptions> CreateAddOptions( 3761 flatbuffers::FlatBufferBuilder &_fbb, 3762 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 3763 AddOptionsBuilder builder_(_fbb); 3764 builder_.add_fused_activation_function(fused_activation_function); 3765 return builder_.Finish(); 3766 } 3767 3768 flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3769 3770 struct MulOptionsT : public flatbuffers::NativeTable { 3771 typedef MulOptions TableType; 3772 ActivationFunctionType fused_activation_function; 3773 MulOptionsT() 3774 : fused_activation_function(ActivationFunctionType_NONE) { 3775 } 3776 }; 3777 3778 struct MulOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3779 typedef MulOptionsT NativeTableType; 3780 enum { 3781 VT_FUSED_ACTIVATION_FUNCTION = 4 3782 }; 3783 ActivationFunctionType fused_activation_function() const { 3784 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3785 } 3786 bool Verify(flatbuffers::Verifier &verifier) const { 3787 return VerifyTableStart(verifier) && 3788 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3789 verifier.EndTable(); 3790 } 3791 MulOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3792 void UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3793 static flatbuffers::Offset<MulOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3794 }; 3795 3796 struct MulOptionsBuilder { 3797 flatbuffers::FlatBufferBuilder &fbb_; 3798 flatbuffers::uoffset_t start_; 3799 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3800 fbb_.AddElement<int8_t>(MulOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3801 } 3802 explicit MulOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3803 : fbb_(_fbb) { 3804 start_ = fbb_.StartTable(); 3805 } 3806 MulOptionsBuilder &operator=(const MulOptionsBuilder &); 3807 flatbuffers::Offset<MulOptions> Finish() { 3808 const auto end = fbb_.EndTable(start_); 3809 auto o = flatbuffers::Offset<MulOptions>(end); 3810 return o; 3811 } 3812 }; 3813 3814 inline flatbuffers::Offset<MulOptions> CreateMulOptions( 3815 flatbuffers::FlatBufferBuilder &_fbb, 3816 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 3817 MulOptionsBuilder builder_(_fbb); 3818 builder_.add_fused_activation_function(fused_activation_function); 3819 return builder_.Finish(); 3820 } 3821 3822 flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3823 3824 struct L2NormOptionsT : public flatbuffers::NativeTable { 3825 typedef L2NormOptions TableType; 3826 ActivationFunctionType fused_activation_function; 3827 L2NormOptionsT() 3828 : fused_activation_function(ActivationFunctionType_NONE) { 3829 } 3830 }; 3831 3832 struct L2NormOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3833 typedef L2NormOptionsT NativeTableType; 3834 enum { 3835 VT_FUSED_ACTIVATION_FUNCTION = 4 3836 }; 3837 ActivationFunctionType fused_activation_function() const { 3838 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3839 } 3840 bool Verify(flatbuffers::Verifier &verifier) const { 3841 return VerifyTableStart(verifier) && 3842 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 3843 verifier.EndTable(); 3844 } 3845 L2NormOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3846 void UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3847 static flatbuffers::Offset<L2NormOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3848 }; 3849 3850 struct L2NormOptionsBuilder { 3851 flatbuffers::FlatBufferBuilder &fbb_; 3852 flatbuffers::uoffset_t start_; 3853 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 3854 fbb_.AddElement<int8_t>(L2NormOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 3855 } 3856 explicit L2NormOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3857 : fbb_(_fbb) { 3858 start_ = fbb_.StartTable(); 3859 } 3860 L2NormOptionsBuilder &operator=(const L2NormOptionsBuilder &); 3861 flatbuffers::Offset<L2NormOptions> Finish() { 3862 const auto end = fbb_.EndTable(start_); 3863 auto o = flatbuffers::Offset<L2NormOptions>(end); 3864 return o; 3865 } 3866 }; 3867 3868 inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions( 3869 flatbuffers::FlatBufferBuilder &_fbb, 3870 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 3871 L2NormOptionsBuilder builder_(_fbb); 3872 builder_.add_fused_activation_function(fused_activation_function); 3873 return builder_.Finish(); 3874 } 3875 3876 flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3877 3878 struct LocalResponseNormalizationOptionsT : public flatbuffers::NativeTable { 3879 typedef LocalResponseNormalizationOptions TableType; 3880 int32_t radius; 3881 float bias; 3882 float alpha; 3883 float beta; 3884 LocalResponseNormalizationOptionsT() 3885 : radius(0), 3886 bias(0.0f), 3887 alpha(0.0f), 3888 beta(0.0f) { 3889 } 3890 }; 3891 3892 struct LocalResponseNormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3893 typedef LocalResponseNormalizationOptionsT NativeTableType; 3894 enum { 3895 VT_RADIUS = 4, 3896 VT_BIAS = 6, 3897 VT_ALPHA = 8, 3898 VT_BETA = 10 3899 }; 3900 int32_t radius() const { 3901 return GetField<int32_t>(VT_RADIUS, 0); 3902 } 3903 float bias() const { 3904 return GetField<float>(VT_BIAS, 0.0f); 3905 } 3906 float alpha() const { 3907 return GetField<float>(VT_ALPHA, 0.0f); 3908 } 3909 float beta() const { 3910 return GetField<float>(VT_BETA, 0.0f); 3911 } 3912 bool Verify(flatbuffers::Verifier &verifier) const { 3913 return VerifyTableStart(verifier) && 3914 VerifyField<int32_t>(verifier, VT_RADIUS) && 3915 VerifyField<float>(verifier, VT_BIAS) && 3916 VerifyField<float>(verifier, VT_ALPHA) && 3917 VerifyField<float>(verifier, VT_BETA) && 3918 verifier.EndTable(); 3919 } 3920 LocalResponseNormalizationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3921 void UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 3922 static flatbuffers::Offset<LocalResponseNormalizationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3923 }; 3924 3925 struct LocalResponseNormalizationOptionsBuilder { 3926 flatbuffers::FlatBufferBuilder &fbb_; 3927 flatbuffers::uoffset_t start_; 3928 void add_radius(int32_t radius) { 3929 fbb_.AddElement<int32_t>(LocalResponseNormalizationOptions::VT_RADIUS, radius, 0); 3930 } 3931 void add_bias(float bias) { 3932 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BIAS, bias, 0.0f); 3933 } 3934 void add_alpha(float alpha) { 3935 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_ALPHA, alpha, 0.0f); 3936 } 3937 void add_beta(float beta) { 3938 fbb_.AddElement<float>(LocalResponseNormalizationOptions::VT_BETA, beta, 0.0f); 3939 } 3940 explicit LocalResponseNormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 3941 : fbb_(_fbb) { 3942 start_ = fbb_.StartTable(); 3943 } 3944 LocalResponseNormalizationOptionsBuilder &operator=(const LocalResponseNormalizationOptionsBuilder &); 3945 flatbuffers::Offset<LocalResponseNormalizationOptions> Finish() { 3946 const auto end = fbb_.EndTable(start_); 3947 auto o = flatbuffers::Offset<LocalResponseNormalizationOptions>(end); 3948 return o; 3949 } 3950 }; 3951 3952 inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions( 3953 flatbuffers::FlatBufferBuilder &_fbb, 3954 int32_t radius = 0, 3955 float bias = 0.0f, 3956 float alpha = 0.0f, 3957 float beta = 0.0f) { 3958 LocalResponseNormalizationOptionsBuilder builder_(_fbb); 3959 builder_.add_beta(beta); 3960 builder_.add_alpha(alpha); 3961 builder_.add_bias(bias); 3962 builder_.add_radius(radius); 3963 return builder_.Finish(); 3964 } 3965 3966 flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 3967 3968 struct LSTMOptionsT : public flatbuffers::NativeTable { 3969 typedef LSTMOptions TableType; 3970 ActivationFunctionType fused_activation_function; 3971 float cell_clip; 3972 float proj_clip; 3973 LSTMKernelType kernel_type; 3974 LSTMOptionsT() 3975 : fused_activation_function(ActivationFunctionType_NONE), 3976 cell_clip(0.0f), 3977 proj_clip(0.0f), 3978 kernel_type(LSTMKernelType_FULL) { 3979 } 3980 }; 3981 3982 struct LSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 3983 typedef LSTMOptionsT NativeTableType; 3984 enum { 3985 VT_FUSED_ACTIVATION_FUNCTION = 4, 3986 VT_CELL_CLIP = 6, 3987 VT_PROJ_CLIP = 8, 3988 VT_KERNEL_TYPE = 10 3989 }; 3990 ActivationFunctionType fused_activation_function() const { 3991 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 3992 } 3993 float cell_clip() const { 3994 return GetField<float>(VT_CELL_CLIP, 0.0f); 3995 } 3996 float proj_clip() const { 3997 return GetField<float>(VT_PROJ_CLIP, 0.0f); 3998 } 3999 LSTMKernelType kernel_type() const { 4000 return static_cast<LSTMKernelType>(GetField<int8_t>(VT_KERNEL_TYPE, 0)); 4001 } 4002 bool Verify(flatbuffers::Verifier &verifier) const { 4003 return VerifyTableStart(verifier) && 4004 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 4005 VerifyField<float>(verifier, VT_CELL_CLIP) && 4006 VerifyField<float>(verifier, VT_PROJ_CLIP) && 4007 VerifyField<int8_t>(verifier, VT_KERNEL_TYPE) && 4008 verifier.EndTable(); 4009 } 4010 LSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4011 void UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4012 static flatbuffers::Offset<LSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4013 }; 4014 4015 struct LSTMOptionsBuilder { 4016 flatbuffers::FlatBufferBuilder &fbb_; 4017 flatbuffers::uoffset_t start_; 4018 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 4019 fbb_.AddElement<int8_t>(LSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 4020 } 4021 void add_cell_clip(float cell_clip) { 4022 fbb_.AddElement<float>(LSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f); 4023 } 4024 void add_proj_clip(float proj_clip) { 4025 fbb_.AddElement<float>(LSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f); 4026 } 4027 void add_kernel_type(LSTMKernelType kernel_type) { 4028 fbb_.AddElement<int8_t>(LSTMOptions::VT_KERNEL_TYPE, static_cast<int8_t>(kernel_type), 0); 4029 } 4030 explicit LSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4031 : fbb_(_fbb) { 4032 start_ = fbb_.StartTable(); 4033 } 4034 LSTMOptionsBuilder &operator=(const LSTMOptionsBuilder &); 4035 flatbuffers::Offset<LSTMOptions> Finish() { 4036 const auto end = fbb_.EndTable(start_); 4037 auto o = flatbuffers::Offset<LSTMOptions>(end); 4038 return o; 4039 } 4040 }; 4041 4042 inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions( 4043 flatbuffers::FlatBufferBuilder &_fbb, 4044 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, 4045 float cell_clip = 0.0f, 4046 float proj_clip = 0.0f, 4047 LSTMKernelType kernel_type = LSTMKernelType_FULL) { 4048 LSTMOptionsBuilder builder_(_fbb); 4049 builder_.add_proj_clip(proj_clip); 4050 builder_.add_cell_clip(cell_clip); 4051 builder_.add_kernel_type(kernel_type); 4052 builder_.add_fused_activation_function(fused_activation_function); 4053 return builder_.Finish(); 4054 } 4055 4056 flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4057 4058 struct UnidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable { 4059 typedef UnidirectionalSequenceLSTMOptions TableType; 4060 ActivationFunctionType fused_activation_function; 4061 float cell_clip; 4062 float proj_clip; 4063 bool time_major; 4064 UnidirectionalSequenceLSTMOptionsT() 4065 : fused_activation_function(ActivationFunctionType_NONE), 4066 cell_clip(0.0f), 4067 proj_clip(0.0f), 4068 time_major(false) { 4069 } 4070 }; 4071 4072 struct UnidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4073 typedef UnidirectionalSequenceLSTMOptionsT NativeTableType; 4074 enum { 4075 VT_FUSED_ACTIVATION_FUNCTION = 4, 4076 VT_CELL_CLIP = 6, 4077 VT_PROJ_CLIP = 8, 4078 VT_TIME_MAJOR = 10 4079 }; 4080 ActivationFunctionType fused_activation_function() const { 4081 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 4082 } 4083 float cell_clip() const { 4084 return GetField<float>(VT_CELL_CLIP, 0.0f); 4085 } 4086 float proj_clip() const { 4087 return GetField<float>(VT_PROJ_CLIP, 0.0f); 4088 } 4089 bool time_major() const { 4090 return GetField<uint8_t>(VT_TIME_MAJOR, 0) != 0; 4091 } 4092 bool Verify(flatbuffers::Verifier &verifier) const { 4093 return VerifyTableStart(verifier) && 4094 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 4095 VerifyField<float>(verifier, VT_CELL_CLIP) && 4096 VerifyField<float>(verifier, VT_PROJ_CLIP) && 4097 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) && 4098 verifier.EndTable(); 4099 } 4100 UnidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4101 void UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4102 static flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4103 }; 4104 4105 struct UnidirectionalSequenceLSTMOptionsBuilder { 4106 flatbuffers::FlatBufferBuilder &fbb_; 4107 flatbuffers::uoffset_t start_; 4108 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 4109 fbb_.AddElement<int8_t>(UnidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 4110 } 4111 void add_cell_clip(float cell_clip) { 4112 fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f); 4113 } 4114 void add_proj_clip(float proj_clip) { 4115 fbb_.AddElement<float>(UnidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f); 4116 } 4117 void add_time_major(bool time_major) { 4118 fbb_.AddElement<uint8_t>(UnidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 0); 4119 } 4120 explicit UnidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4121 : fbb_(_fbb) { 4122 start_ = fbb_.StartTable(); 4123 } 4124 UnidirectionalSequenceLSTMOptionsBuilder &operator=(const UnidirectionalSequenceLSTMOptionsBuilder &); 4125 flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> Finish() { 4126 const auto end = fbb_.EndTable(start_); 4127 auto o = flatbuffers::Offset<UnidirectionalSequenceLSTMOptions>(end); 4128 return o; 4129 } 4130 }; 4131 4132 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions( 4133 flatbuffers::FlatBufferBuilder &_fbb, 4134 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, 4135 float cell_clip = 0.0f, 4136 float proj_clip = 0.0f, 4137 bool time_major = false) { 4138 UnidirectionalSequenceLSTMOptionsBuilder builder_(_fbb); 4139 builder_.add_proj_clip(proj_clip); 4140 builder_.add_cell_clip(cell_clip); 4141 builder_.add_time_major(time_major); 4142 builder_.add_fused_activation_function(fused_activation_function); 4143 return builder_.Finish(); 4144 } 4145 4146 flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4147 4148 struct BidirectionalSequenceLSTMOptionsT : public flatbuffers::NativeTable { 4149 typedef BidirectionalSequenceLSTMOptions TableType; 4150 ActivationFunctionType fused_activation_function; 4151 float cell_clip; 4152 float proj_clip; 4153 bool merge_outputs; 4154 bool time_major; 4155 BidirectionalSequenceLSTMOptionsT() 4156 : fused_activation_function(ActivationFunctionType_NONE), 4157 cell_clip(0.0f), 4158 proj_clip(0.0f), 4159 merge_outputs(false), 4160 time_major(true) { 4161 } 4162 }; 4163 4164 struct BidirectionalSequenceLSTMOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4165 typedef BidirectionalSequenceLSTMOptionsT NativeTableType; 4166 enum { 4167 VT_FUSED_ACTIVATION_FUNCTION = 4, 4168 VT_CELL_CLIP = 6, 4169 VT_PROJ_CLIP = 8, 4170 VT_MERGE_OUTPUTS = 10, 4171 VT_TIME_MAJOR = 12 4172 }; 4173 ActivationFunctionType fused_activation_function() const { 4174 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 4175 } 4176 float cell_clip() const { 4177 return GetField<float>(VT_CELL_CLIP, 0.0f); 4178 } 4179 float proj_clip() const { 4180 return GetField<float>(VT_PROJ_CLIP, 0.0f); 4181 } 4182 bool merge_outputs() const { 4183 return GetField<uint8_t>(VT_MERGE_OUTPUTS, 0) != 0; 4184 } 4185 bool time_major() const { 4186 return GetField<uint8_t>(VT_TIME_MAJOR, 1) != 0; 4187 } 4188 bool Verify(flatbuffers::Verifier &verifier) const { 4189 return VerifyTableStart(verifier) && 4190 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 4191 VerifyField<float>(verifier, VT_CELL_CLIP) && 4192 VerifyField<float>(verifier, VT_PROJ_CLIP) && 4193 VerifyField<uint8_t>(verifier, VT_MERGE_OUTPUTS) && 4194 VerifyField<uint8_t>(verifier, VT_TIME_MAJOR) && 4195 verifier.EndTable(); 4196 } 4197 BidirectionalSequenceLSTMOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4198 void UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4199 static flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4200 }; 4201 4202 struct BidirectionalSequenceLSTMOptionsBuilder { 4203 flatbuffers::FlatBufferBuilder &fbb_; 4204 flatbuffers::uoffset_t start_; 4205 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 4206 fbb_.AddElement<int8_t>(BidirectionalSequenceLSTMOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 4207 } 4208 void add_cell_clip(float cell_clip) { 4209 fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_CELL_CLIP, cell_clip, 0.0f); 4210 } 4211 void add_proj_clip(float proj_clip) { 4212 fbb_.AddElement<float>(BidirectionalSequenceLSTMOptions::VT_PROJ_CLIP, proj_clip, 0.0f); 4213 } 4214 void add_merge_outputs(bool merge_outputs) { 4215 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_MERGE_OUTPUTS, static_cast<uint8_t>(merge_outputs), 0); 4216 } 4217 void add_time_major(bool time_major) { 4218 fbb_.AddElement<uint8_t>(BidirectionalSequenceLSTMOptions::VT_TIME_MAJOR, static_cast<uint8_t>(time_major), 1); 4219 } 4220 explicit BidirectionalSequenceLSTMOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4221 : fbb_(_fbb) { 4222 start_ = fbb_.StartTable(); 4223 } 4224 BidirectionalSequenceLSTMOptionsBuilder &operator=(const BidirectionalSequenceLSTMOptionsBuilder &); 4225 flatbuffers::Offset<BidirectionalSequenceLSTMOptions> Finish() { 4226 const auto end = fbb_.EndTable(start_); 4227 auto o = flatbuffers::Offset<BidirectionalSequenceLSTMOptions>(end); 4228 return o; 4229 } 4230 }; 4231 4232 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions( 4233 flatbuffers::FlatBufferBuilder &_fbb, 4234 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE, 4235 float cell_clip = 0.0f, 4236 float proj_clip = 0.0f, 4237 bool merge_outputs = false, 4238 bool time_major = true) { 4239 BidirectionalSequenceLSTMOptionsBuilder builder_(_fbb); 4240 builder_.add_proj_clip(proj_clip); 4241 builder_.add_cell_clip(cell_clip); 4242 builder_.add_time_major(time_major); 4243 builder_.add_merge_outputs(merge_outputs); 4244 builder_.add_fused_activation_function(fused_activation_function); 4245 return builder_.Finish(); 4246 } 4247 4248 flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4249 4250 struct ResizeBilinearOptionsT : public flatbuffers::NativeTable { 4251 typedef ResizeBilinearOptions TableType; 4252 bool align_corners; 4253 ResizeBilinearOptionsT() 4254 : align_corners(false) { 4255 } 4256 }; 4257 4258 struct ResizeBilinearOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4259 typedef ResizeBilinearOptionsT NativeTableType; 4260 enum { 4261 VT_ALIGN_CORNERS = 8 4262 }; 4263 bool align_corners() const { 4264 return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; 4265 } 4266 bool Verify(flatbuffers::Verifier &verifier) const { 4267 return VerifyTableStart(verifier) && 4268 VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) && 4269 verifier.EndTable(); 4270 } 4271 ResizeBilinearOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4272 void UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4273 static flatbuffers::Offset<ResizeBilinearOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4274 }; 4275 4276 struct ResizeBilinearOptionsBuilder { 4277 flatbuffers::FlatBufferBuilder &fbb_; 4278 flatbuffers::uoffset_t start_; 4279 void add_align_corners(bool align_corners) { 4280 fbb_.AddElement<uint8_t>(ResizeBilinearOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0); 4281 } 4282 explicit ResizeBilinearOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4283 : fbb_(_fbb) { 4284 start_ = fbb_.StartTable(); 4285 } 4286 ResizeBilinearOptionsBuilder &operator=(const ResizeBilinearOptionsBuilder &); 4287 flatbuffers::Offset<ResizeBilinearOptions> Finish() { 4288 const auto end = fbb_.EndTable(start_); 4289 auto o = flatbuffers::Offset<ResizeBilinearOptions>(end); 4290 return o; 4291 } 4292 }; 4293 4294 inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions( 4295 flatbuffers::FlatBufferBuilder &_fbb, 4296 bool align_corners = false) { 4297 ResizeBilinearOptionsBuilder builder_(_fbb); 4298 builder_.add_align_corners(align_corners); 4299 return builder_.Finish(); 4300 } 4301 4302 flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4303 4304 struct ResizeNearestNeighborOptionsT : public flatbuffers::NativeTable { 4305 typedef ResizeNearestNeighborOptions TableType; 4306 bool align_corners; 4307 ResizeNearestNeighborOptionsT() 4308 : align_corners(false) { 4309 } 4310 }; 4311 4312 struct ResizeNearestNeighborOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4313 typedef ResizeNearestNeighborOptionsT NativeTableType; 4314 enum { 4315 VT_ALIGN_CORNERS = 4 4316 }; 4317 bool align_corners() const { 4318 return GetField<uint8_t>(VT_ALIGN_CORNERS, 0) != 0; 4319 } 4320 bool Verify(flatbuffers::Verifier &verifier) const { 4321 return VerifyTableStart(verifier) && 4322 VerifyField<uint8_t>(verifier, VT_ALIGN_CORNERS) && 4323 verifier.EndTable(); 4324 } 4325 ResizeNearestNeighborOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4326 void UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4327 static flatbuffers::Offset<ResizeNearestNeighborOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4328 }; 4329 4330 struct ResizeNearestNeighborOptionsBuilder { 4331 flatbuffers::FlatBufferBuilder &fbb_; 4332 flatbuffers::uoffset_t start_; 4333 void add_align_corners(bool align_corners) { 4334 fbb_.AddElement<uint8_t>(ResizeNearestNeighborOptions::VT_ALIGN_CORNERS, static_cast<uint8_t>(align_corners), 0); 4335 } 4336 explicit ResizeNearestNeighborOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4337 : fbb_(_fbb) { 4338 start_ = fbb_.StartTable(); 4339 } 4340 ResizeNearestNeighborOptionsBuilder &operator=(const ResizeNearestNeighborOptionsBuilder &); 4341 flatbuffers::Offset<ResizeNearestNeighborOptions> Finish() { 4342 const auto end = fbb_.EndTable(start_); 4343 auto o = flatbuffers::Offset<ResizeNearestNeighborOptions>(end); 4344 return o; 4345 } 4346 }; 4347 4348 inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions( 4349 flatbuffers::FlatBufferBuilder &_fbb, 4350 bool align_corners = false) { 4351 ResizeNearestNeighborOptionsBuilder builder_(_fbb); 4352 builder_.add_align_corners(align_corners); 4353 return builder_.Finish(); 4354 } 4355 4356 flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4357 4358 struct CallOptionsT : public flatbuffers::NativeTable { 4359 typedef CallOptions TableType; 4360 uint32_t subgraph; 4361 CallOptionsT() 4362 : subgraph(0) { 4363 } 4364 }; 4365 4366 struct CallOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4367 typedef CallOptionsT NativeTableType; 4368 enum { 4369 VT_SUBGRAPH = 4 4370 }; 4371 uint32_t subgraph() const { 4372 return GetField<uint32_t>(VT_SUBGRAPH, 0); 4373 } 4374 bool Verify(flatbuffers::Verifier &verifier) const { 4375 return VerifyTableStart(verifier) && 4376 VerifyField<uint32_t>(verifier, VT_SUBGRAPH) && 4377 verifier.EndTable(); 4378 } 4379 CallOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4380 void UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4381 static flatbuffers::Offset<CallOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4382 }; 4383 4384 struct CallOptionsBuilder { 4385 flatbuffers::FlatBufferBuilder &fbb_; 4386 flatbuffers::uoffset_t start_; 4387 void add_subgraph(uint32_t subgraph) { 4388 fbb_.AddElement<uint32_t>(CallOptions::VT_SUBGRAPH, subgraph, 0); 4389 } 4390 explicit CallOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4391 : fbb_(_fbb) { 4392 start_ = fbb_.StartTable(); 4393 } 4394 CallOptionsBuilder &operator=(const CallOptionsBuilder &); 4395 flatbuffers::Offset<CallOptions> Finish() { 4396 const auto end = fbb_.EndTable(start_); 4397 auto o = flatbuffers::Offset<CallOptions>(end); 4398 return o; 4399 } 4400 }; 4401 4402 inline flatbuffers::Offset<CallOptions> CreateCallOptions( 4403 flatbuffers::FlatBufferBuilder &_fbb, 4404 uint32_t subgraph = 0) { 4405 CallOptionsBuilder builder_(_fbb); 4406 builder_.add_subgraph(subgraph); 4407 return builder_.Finish(); 4408 } 4409 4410 flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4411 4412 struct PadOptionsT : public flatbuffers::NativeTable { 4413 typedef PadOptions TableType; 4414 PadOptionsT() { 4415 } 4416 }; 4417 4418 struct PadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4419 typedef PadOptionsT NativeTableType; 4420 bool Verify(flatbuffers::Verifier &verifier) const { 4421 return VerifyTableStart(verifier) && 4422 verifier.EndTable(); 4423 } 4424 PadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4425 void UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4426 static flatbuffers::Offset<PadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4427 }; 4428 4429 struct PadOptionsBuilder { 4430 flatbuffers::FlatBufferBuilder &fbb_; 4431 flatbuffers::uoffset_t start_; 4432 explicit PadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4433 : fbb_(_fbb) { 4434 start_ = fbb_.StartTable(); 4435 } 4436 PadOptionsBuilder &operator=(const PadOptionsBuilder &); 4437 flatbuffers::Offset<PadOptions> Finish() { 4438 const auto end = fbb_.EndTable(start_); 4439 auto o = flatbuffers::Offset<PadOptions>(end); 4440 return o; 4441 } 4442 }; 4443 4444 inline flatbuffers::Offset<PadOptions> CreatePadOptions( 4445 flatbuffers::FlatBufferBuilder &_fbb) { 4446 PadOptionsBuilder builder_(_fbb); 4447 return builder_.Finish(); 4448 } 4449 4450 flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4451 4452 struct PadV2OptionsT : public flatbuffers::NativeTable { 4453 typedef PadV2Options TableType; 4454 PadV2OptionsT() { 4455 } 4456 }; 4457 4458 struct PadV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4459 typedef PadV2OptionsT NativeTableType; 4460 bool Verify(flatbuffers::Verifier &verifier) const { 4461 return VerifyTableStart(verifier) && 4462 verifier.EndTable(); 4463 } 4464 PadV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4465 void UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4466 static flatbuffers::Offset<PadV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4467 }; 4468 4469 struct PadV2OptionsBuilder { 4470 flatbuffers::FlatBufferBuilder &fbb_; 4471 flatbuffers::uoffset_t start_; 4472 explicit PadV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4473 : fbb_(_fbb) { 4474 start_ = fbb_.StartTable(); 4475 } 4476 PadV2OptionsBuilder &operator=(const PadV2OptionsBuilder &); 4477 flatbuffers::Offset<PadV2Options> Finish() { 4478 const auto end = fbb_.EndTable(start_); 4479 auto o = flatbuffers::Offset<PadV2Options>(end); 4480 return o; 4481 } 4482 }; 4483 4484 inline flatbuffers::Offset<PadV2Options> CreatePadV2Options( 4485 flatbuffers::FlatBufferBuilder &_fbb) { 4486 PadV2OptionsBuilder builder_(_fbb); 4487 return builder_.Finish(); 4488 } 4489 4490 flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4491 4492 struct ReshapeOptionsT : public flatbuffers::NativeTable { 4493 typedef ReshapeOptions TableType; 4494 std::vector<int32_t> new_shape; 4495 ReshapeOptionsT() { 4496 } 4497 }; 4498 4499 struct ReshapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4500 typedef ReshapeOptionsT NativeTableType; 4501 enum { 4502 VT_NEW_SHAPE = 4 4503 }; 4504 const flatbuffers::Vector<int32_t> *new_shape() const { 4505 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_NEW_SHAPE); 4506 } 4507 bool Verify(flatbuffers::Verifier &verifier) const { 4508 return VerifyTableStart(verifier) && 4509 VerifyOffset(verifier, VT_NEW_SHAPE) && 4510 verifier.VerifyVector(new_shape()) && 4511 verifier.EndTable(); 4512 } 4513 ReshapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4514 void UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4515 static flatbuffers::Offset<ReshapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4516 }; 4517 4518 struct ReshapeOptionsBuilder { 4519 flatbuffers::FlatBufferBuilder &fbb_; 4520 flatbuffers::uoffset_t start_; 4521 void add_new_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape) { 4522 fbb_.AddOffset(ReshapeOptions::VT_NEW_SHAPE, new_shape); 4523 } 4524 explicit ReshapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4525 : fbb_(_fbb) { 4526 start_ = fbb_.StartTable(); 4527 } 4528 ReshapeOptionsBuilder &operator=(const ReshapeOptionsBuilder &); 4529 flatbuffers::Offset<ReshapeOptions> Finish() { 4530 const auto end = fbb_.EndTable(start_); 4531 auto o = flatbuffers::Offset<ReshapeOptions>(end); 4532 return o; 4533 } 4534 }; 4535 4536 inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions( 4537 flatbuffers::FlatBufferBuilder &_fbb, 4538 flatbuffers::Offset<flatbuffers::Vector<int32_t>> new_shape = 0) { 4539 ReshapeOptionsBuilder builder_(_fbb); 4540 builder_.add_new_shape(new_shape); 4541 return builder_.Finish(); 4542 } 4543 4544 inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptionsDirect( 4545 flatbuffers::FlatBufferBuilder &_fbb, 4546 const std::vector<int32_t> *new_shape = nullptr) { 4547 return tflite::CreateReshapeOptions( 4548 _fbb, 4549 new_shape ? _fbb.CreateVector<int32_t>(*new_shape) : 0); 4550 } 4551 4552 flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4553 4554 struct SpaceToBatchNDOptionsT : public flatbuffers::NativeTable { 4555 typedef SpaceToBatchNDOptions TableType; 4556 SpaceToBatchNDOptionsT() { 4557 } 4558 }; 4559 4560 struct SpaceToBatchNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4561 typedef SpaceToBatchNDOptionsT NativeTableType; 4562 bool Verify(flatbuffers::Verifier &verifier) const { 4563 return VerifyTableStart(verifier) && 4564 verifier.EndTable(); 4565 } 4566 SpaceToBatchNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4567 void UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4568 static flatbuffers::Offset<SpaceToBatchNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4569 }; 4570 4571 struct SpaceToBatchNDOptionsBuilder { 4572 flatbuffers::FlatBufferBuilder &fbb_; 4573 flatbuffers::uoffset_t start_; 4574 explicit SpaceToBatchNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4575 : fbb_(_fbb) { 4576 start_ = fbb_.StartTable(); 4577 } 4578 SpaceToBatchNDOptionsBuilder &operator=(const SpaceToBatchNDOptionsBuilder &); 4579 flatbuffers::Offset<SpaceToBatchNDOptions> Finish() { 4580 const auto end = fbb_.EndTable(start_); 4581 auto o = flatbuffers::Offset<SpaceToBatchNDOptions>(end); 4582 return o; 4583 } 4584 }; 4585 4586 inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions( 4587 flatbuffers::FlatBufferBuilder &_fbb) { 4588 SpaceToBatchNDOptionsBuilder builder_(_fbb); 4589 return builder_.Finish(); 4590 } 4591 4592 flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4593 4594 struct BatchToSpaceNDOptionsT : public flatbuffers::NativeTable { 4595 typedef BatchToSpaceNDOptions TableType; 4596 BatchToSpaceNDOptionsT() { 4597 } 4598 }; 4599 4600 struct BatchToSpaceNDOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4601 typedef BatchToSpaceNDOptionsT NativeTableType; 4602 bool Verify(flatbuffers::Verifier &verifier) const { 4603 return VerifyTableStart(verifier) && 4604 verifier.EndTable(); 4605 } 4606 BatchToSpaceNDOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4607 void UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4608 static flatbuffers::Offset<BatchToSpaceNDOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4609 }; 4610 4611 struct BatchToSpaceNDOptionsBuilder { 4612 flatbuffers::FlatBufferBuilder &fbb_; 4613 flatbuffers::uoffset_t start_; 4614 explicit BatchToSpaceNDOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4615 : fbb_(_fbb) { 4616 start_ = fbb_.StartTable(); 4617 } 4618 BatchToSpaceNDOptionsBuilder &operator=(const BatchToSpaceNDOptionsBuilder &); 4619 flatbuffers::Offset<BatchToSpaceNDOptions> Finish() { 4620 const auto end = fbb_.EndTable(start_); 4621 auto o = flatbuffers::Offset<BatchToSpaceNDOptions>(end); 4622 return o; 4623 } 4624 }; 4625 4626 inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions( 4627 flatbuffers::FlatBufferBuilder &_fbb) { 4628 BatchToSpaceNDOptionsBuilder builder_(_fbb); 4629 return builder_.Finish(); 4630 } 4631 4632 flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4633 4634 struct SkipGramOptionsT : public flatbuffers::NativeTable { 4635 typedef SkipGramOptions TableType; 4636 int32_t ngram_size; 4637 int32_t max_skip_size; 4638 bool include_all_ngrams; 4639 SkipGramOptionsT() 4640 : ngram_size(0), 4641 max_skip_size(0), 4642 include_all_ngrams(false) { 4643 } 4644 }; 4645 4646 struct SkipGramOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4647 typedef SkipGramOptionsT NativeTableType; 4648 enum { 4649 VT_NGRAM_SIZE = 4, 4650 VT_MAX_SKIP_SIZE = 6, 4651 VT_INCLUDE_ALL_NGRAMS = 8 4652 }; 4653 int32_t ngram_size() const { 4654 return GetField<int32_t>(VT_NGRAM_SIZE, 0); 4655 } 4656 int32_t max_skip_size() const { 4657 return GetField<int32_t>(VT_MAX_SKIP_SIZE, 0); 4658 } 4659 bool include_all_ngrams() const { 4660 return GetField<uint8_t>(VT_INCLUDE_ALL_NGRAMS, 0) != 0; 4661 } 4662 bool Verify(flatbuffers::Verifier &verifier) const { 4663 return VerifyTableStart(verifier) && 4664 VerifyField<int32_t>(verifier, VT_NGRAM_SIZE) && 4665 VerifyField<int32_t>(verifier, VT_MAX_SKIP_SIZE) && 4666 VerifyField<uint8_t>(verifier, VT_INCLUDE_ALL_NGRAMS) && 4667 verifier.EndTable(); 4668 } 4669 SkipGramOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4670 void UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4671 static flatbuffers::Offset<SkipGramOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4672 }; 4673 4674 struct SkipGramOptionsBuilder { 4675 flatbuffers::FlatBufferBuilder &fbb_; 4676 flatbuffers::uoffset_t start_; 4677 void add_ngram_size(int32_t ngram_size) { 4678 fbb_.AddElement<int32_t>(SkipGramOptions::VT_NGRAM_SIZE, ngram_size, 0); 4679 } 4680 void add_max_skip_size(int32_t max_skip_size) { 4681 fbb_.AddElement<int32_t>(SkipGramOptions::VT_MAX_SKIP_SIZE, max_skip_size, 0); 4682 } 4683 void add_include_all_ngrams(bool include_all_ngrams) { 4684 fbb_.AddElement<uint8_t>(SkipGramOptions::VT_INCLUDE_ALL_NGRAMS, static_cast<uint8_t>(include_all_ngrams), 0); 4685 } 4686 explicit SkipGramOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4687 : fbb_(_fbb) { 4688 start_ = fbb_.StartTable(); 4689 } 4690 SkipGramOptionsBuilder &operator=(const SkipGramOptionsBuilder &); 4691 flatbuffers::Offset<SkipGramOptions> Finish() { 4692 const auto end = fbb_.EndTable(start_); 4693 auto o = flatbuffers::Offset<SkipGramOptions>(end); 4694 return o; 4695 } 4696 }; 4697 4698 inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions( 4699 flatbuffers::FlatBufferBuilder &_fbb, 4700 int32_t ngram_size = 0, 4701 int32_t max_skip_size = 0, 4702 bool include_all_ngrams = false) { 4703 SkipGramOptionsBuilder builder_(_fbb); 4704 builder_.add_max_skip_size(max_skip_size); 4705 builder_.add_ngram_size(ngram_size); 4706 builder_.add_include_all_ngrams(include_all_ngrams); 4707 return builder_.Finish(); 4708 } 4709 4710 flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4711 4712 struct SpaceToDepthOptionsT : public flatbuffers::NativeTable { 4713 typedef SpaceToDepthOptions TableType; 4714 int32_t block_size; 4715 SpaceToDepthOptionsT() 4716 : block_size(0) { 4717 } 4718 }; 4719 4720 struct SpaceToDepthOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4721 typedef SpaceToDepthOptionsT NativeTableType; 4722 enum { 4723 VT_BLOCK_SIZE = 4 4724 }; 4725 int32_t block_size() const { 4726 return GetField<int32_t>(VT_BLOCK_SIZE, 0); 4727 } 4728 bool Verify(flatbuffers::Verifier &verifier) const { 4729 return VerifyTableStart(verifier) && 4730 VerifyField<int32_t>(verifier, VT_BLOCK_SIZE) && 4731 verifier.EndTable(); 4732 } 4733 SpaceToDepthOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4734 void UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4735 static flatbuffers::Offset<SpaceToDepthOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4736 }; 4737 4738 struct SpaceToDepthOptionsBuilder { 4739 flatbuffers::FlatBufferBuilder &fbb_; 4740 flatbuffers::uoffset_t start_; 4741 void add_block_size(int32_t block_size) { 4742 fbb_.AddElement<int32_t>(SpaceToDepthOptions::VT_BLOCK_SIZE, block_size, 0); 4743 } 4744 explicit SpaceToDepthOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4745 : fbb_(_fbb) { 4746 start_ = fbb_.StartTable(); 4747 } 4748 SpaceToDepthOptionsBuilder &operator=(const SpaceToDepthOptionsBuilder &); 4749 flatbuffers::Offset<SpaceToDepthOptions> Finish() { 4750 const auto end = fbb_.EndTable(start_); 4751 auto o = flatbuffers::Offset<SpaceToDepthOptions>(end); 4752 return o; 4753 } 4754 }; 4755 4756 inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions( 4757 flatbuffers::FlatBufferBuilder &_fbb, 4758 int32_t block_size = 0) { 4759 SpaceToDepthOptionsBuilder builder_(_fbb); 4760 builder_.add_block_size(block_size); 4761 return builder_.Finish(); 4762 } 4763 4764 flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4765 4766 struct SubOptionsT : public flatbuffers::NativeTable { 4767 typedef SubOptions TableType; 4768 ActivationFunctionType fused_activation_function; 4769 SubOptionsT() 4770 : fused_activation_function(ActivationFunctionType_NONE) { 4771 } 4772 }; 4773 4774 struct SubOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4775 typedef SubOptionsT NativeTableType; 4776 enum { 4777 VT_FUSED_ACTIVATION_FUNCTION = 4 4778 }; 4779 ActivationFunctionType fused_activation_function() const { 4780 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 4781 } 4782 bool Verify(flatbuffers::Verifier &verifier) const { 4783 return VerifyTableStart(verifier) && 4784 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 4785 verifier.EndTable(); 4786 } 4787 SubOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4788 void UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4789 static flatbuffers::Offset<SubOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4790 }; 4791 4792 struct SubOptionsBuilder { 4793 flatbuffers::FlatBufferBuilder &fbb_; 4794 flatbuffers::uoffset_t start_; 4795 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 4796 fbb_.AddElement<int8_t>(SubOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 4797 } 4798 explicit SubOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4799 : fbb_(_fbb) { 4800 start_ = fbb_.StartTable(); 4801 } 4802 SubOptionsBuilder &operator=(const SubOptionsBuilder &); 4803 flatbuffers::Offset<SubOptions> Finish() { 4804 const auto end = fbb_.EndTable(start_); 4805 auto o = flatbuffers::Offset<SubOptions>(end); 4806 return o; 4807 } 4808 }; 4809 4810 inline flatbuffers::Offset<SubOptions> CreateSubOptions( 4811 flatbuffers::FlatBufferBuilder &_fbb, 4812 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 4813 SubOptionsBuilder builder_(_fbb); 4814 builder_.add_fused_activation_function(fused_activation_function); 4815 return builder_.Finish(); 4816 } 4817 4818 flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4819 4820 struct DivOptionsT : public flatbuffers::NativeTable { 4821 typedef DivOptions TableType; 4822 ActivationFunctionType fused_activation_function; 4823 DivOptionsT() 4824 : fused_activation_function(ActivationFunctionType_NONE) { 4825 } 4826 }; 4827 4828 struct DivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4829 typedef DivOptionsT NativeTableType; 4830 enum { 4831 VT_FUSED_ACTIVATION_FUNCTION = 4 4832 }; 4833 ActivationFunctionType fused_activation_function() const { 4834 return static_cast<ActivationFunctionType>(GetField<int8_t>(VT_FUSED_ACTIVATION_FUNCTION, 0)); 4835 } 4836 bool Verify(flatbuffers::Verifier &verifier) const { 4837 return VerifyTableStart(verifier) && 4838 VerifyField<int8_t>(verifier, VT_FUSED_ACTIVATION_FUNCTION) && 4839 verifier.EndTable(); 4840 } 4841 DivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4842 void UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4843 static flatbuffers::Offset<DivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4844 }; 4845 4846 struct DivOptionsBuilder { 4847 flatbuffers::FlatBufferBuilder &fbb_; 4848 flatbuffers::uoffset_t start_; 4849 void add_fused_activation_function(ActivationFunctionType fused_activation_function) { 4850 fbb_.AddElement<int8_t>(DivOptions::VT_FUSED_ACTIVATION_FUNCTION, static_cast<int8_t>(fused_activation_function), 0); 4851 } 4852 explicit DivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4853 : fbb_(_fbb) { 4854 start_ = fbb_.StartTable(); 4855 } 4856 DivOptionsBuilder &operator=(const DivOptionsBuilder &); 4857 flatbuffers::Offset<DivOptions> Finish() { 4858 const auto end = fbb_.EndTable(start_); 4859 auto o = flatbuffers::Offset<DivOptions>(end); 4860 return o; 4861 } 4862 }; 4863 4864 inline flatbuffers::Offset<DivOptions> CreateDivOptions( 4865 flatbuffers::FlatBufferBuilder &_fbb, 4866 ActivationFunctionType fused_activation_function = ActivationFunctionType_NONE) { 4867 DivOptionsBuilder builder_(_fbb); 4868 builder_.add_fused_activation_function(fused_activation_function); 4869 return builder_.Finish(); 4870 } 4871 4872 flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4873 4874 struct TopKV2OptionsT : public flatbuffers::NativeTable { 4875 typedef TopKV2Options TableType; 4876 TopKV2OptionsT() { 4877 } 4878 }; 4879 4880 struct TopKV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4881 typedef TopKV2OptionsT NativeTableType; 4882 bool Verify(flatbuffers::Verifier &verifier) const { 4883 return VerifyTableStart(verifier) && 4884 verifier.EndTable(); 4885 } 4886 TopKV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4887 void UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4888 static flatbuffers::Offset<TopKV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4889 }; 4890 4891 struct TopKV2OptionsBuilder { 4892 flatbuffers::FlatBufferBuilder &fbb_; 4893 flatbuffers::uoffset_t start_; 4894 explicit TopKV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4895 : fbb_(_fbb) { 4896 start_ = fbb_.StartTable(); 4897 } 4898 TopKV2OptionsBuilder &operator=(const TopKV2OptionsBuilder &); 4899 flatbuffers::Offset<TopKV2Options> Finish() { 4900 const auto end = fbb_.EndTable(start_); 4901 auto o = flatbuffers::Offset<TopKV2Options>(end); 4902 return o; 4903 } 4904 }; 4905 4906 inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options( 4907 flatbuffers::FlatBufferBuilder &_fbb) { 4908 TopKV2OptionsBuilder builder_(_fbb); 4909 return builder_.Finish(); 4910 } 4911 4912 flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4913 4914 struct EmbeddingLookupSparseOptionsT : public flatbuffers::NativeTable { 4915 typedef EmbeddingLookupSparseOptions TableType; 4916 CombinerType combiner; 4917 EmbeddingLookupSparseOptionsT() 4918 : combiner(CombinerType_SUM) { 4919 } 4920 }; 4921 4922 struct EmbeddingLookupSparseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4923 typedef EmbeddingLookupSparseOptionsT NativeTableType; 4924 enum { 4925 VT_COMBINER = 4 4926 }; 4927 CombinerType combiner() const { 4928 return static_cast<CombinerType>(GetField<int8_t>(VT_COMBINER, 0)); 4929 } 4930 bool Verify(flatbuffers::Verifier &verifier) const { 4931 return VerifyTableStart(verifier) && 4932 VerifyField<int8_t>(verifier, VT_COMBINER) && 4933 verifier.EndTable(); 4934 } 4935 EmbeddingLookupSparseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4936 void UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4937 static flatbuffers::Offset<EmbeddingLookupSparseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4938 }; 4939 4940 struct EmbeddingLookupSparseOptionsBuilder { 4941 flatbuffers::FlatBufferBuilder &fbb_; 4942 flatbuffers::uoffset_t start_; 4943 void add_combiner(CombinerType combiner) { 4944 fbb_.AddElement<int8_t>(EmbeddingLookupSparseOptions::VT_COMBINER, static_cast<int8_t>(combiner), 0); 4945 } 4946 explicit EmbeddingLookupSparseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 4947 : fbb_(_fbb) { 4948 start_ = fbb_.StartTable(); 4949 } 4950 EmbeddingLookupSparseOptionsBuilder &operator=(const EmbeddingLookupSparseOptionsBuilder &); 4951 flatbuffers::Offset<EmbeddingLookupSparseOptions> Finish() { 4952 const auto end = fbb_.EndTable(start_); 4953 auto o = flatbuffers::Offset<EmbeddingLookupSparseOptions>(end); 4954 return o; 4955 } 4956 }; 4957 4958 inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions( 4959 flatbuffers::FlatBufferBuilder &_fbb, 4960 CombinerType combiner = CombinerType_SUM) { 4961 EmbeddingLookupSparseOptionsBuilder builder_(_fbb); 4962 builder_.add_combiner(combiner); 4963 return builder_.Finish(); 4964 } 4965 4966 flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4967 4968 struct GatherOptionsT : public flatbuffers::NativeTable { 4969 typedef GatherOptions TableType; 4970 int32_t axis; 4971 GatherOptionsT() 4972 : axis(0) { 4973 } 4974 }; 4975 4976 struct GatherOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 4977 typedef GatherOptionsT NativeTableType; 4978 enum { 4979 VT_AXIS = 4 4980 }; 4981 int32_t axis() const { 4982 return GetField<int32_t>(VT_AXIS, 0); 4983 } 4984 bool Verify(flatbuffers::Verifier &verifier) const { 4985 return VerifyTableStart(verifier) && 4986 VerifyField<int32_t>(verifier, VT_AXIS) && 4987 verifier.EndTable(); 4988 } 4989 GatherOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4990 void UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 4991 static flatbuffers::Offset<GatherOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 4992 }; 4993 4994 struct GatherOptionsBuilder { 4995 flatbuffers::FlatBufferBuilder &fbb_; 4996 flatbuffers::uoffset_t start_; 4997 void add_axis(int32_t axis) { 4998 fbb_.AddElement<int32_t>(GatherOptions::VT_AXIS, axis, 0); 4999 } 5000 explicit GatherOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5001 : fbb_(_fbb) { 5002 start_ = fbb_.StartTable(); 5003 } 5004 GatherOptionsBuilder &operator=(const GatherOptionsBuilder &); 5005 flatbuffers::Offset<GatherOptions> Finish() { 5006 const auto end = fbb_.EndTable(start_); 5007 auto o = flatbuffers::Offset<GatherOptions>(end); 5008 return o; 5009 } 5010 }; 5011 5012 inline flatbuffers::Offset<GatherOptions> CreateGatherOptions( 5013 flatbuffers::FlatBufferBuilder &_fbb, 5014 int32_t axis = 0) { 5015 GatherOptionsBuilder builder_(_fbb); 5016 builder_.add_axis(axis); 5017 return builder_.Finish(); 5018 } 5019 5020 flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5021 5022 struct TransposeOptionsT : public flatbuffers::NativeTable { 5023 typedef TransposeOptions TableType; 5024 TransposeOptionsT() { 5025 } 5026 }; 5027 5028 struct TransposeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5029 typedef TransposeOptionsT NativeTableType; 5030 bool Verify(flatbuffers::Verifier &verifier) const { 5031 return VerifyTableStart(verifier) && 5032 verifier.EndTable(); 5033 } 5034 TransposeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5035 void UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5036 static flatbuffers::Offset<TransposeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5037 }; 5038 5039 struct TransposeOptionsBuilder { 5040 flatbuffers::FlatBufferBuilder &fbb_; 5041 flatbuffers::uoffset_t start_; 5042 explicit TransposeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5043 : fbb_(_fbb) { 5044 start_ = fbb_.StartTable(); 5045 } 5046 TransposeOptionsBuilder &operator=(const TransposeOptionsBuilder &); 5047 flatbuffers::Offset<TransposeOptions> Finish() { 5048 const auto end = fbb_.EndTable(start_); 5049 auto o = flatbuffers::Offset<TransposeOptions>(end); 5050 return o; 5051 } 5052 }; 5053 5054 inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions( 5055 flatbuffers::FlatBufferBuilder &_fbb) { 5056 TransposeOptionsBuilder builder_(_fbb); 5057 return builder_.Finish(); 5058 } 5059 5060 flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5061 5062 struct ExpOptionsT : public flatbuffers::NativeTable { 5063 typedef ExpOptions TableType; 5064 ExpOptionsT() { 5065 } 5066 }; 5067 5068 struct ExpOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5069 typedef ExpOptionsT NativeTableType; 5070 bool Verify(flatbuffers::Verifier &verifier) const { 5071 return VerifyTableStart(verifier) && 5072 verifier.EndTable(); 5073 } 5074 ExpOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5075 void UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5076 static flatbuffers::Offset<ExpOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5077 }; 5078 5079 struct ExpOptionsBuilder { 5080 flatbuffers::FlatBufferBuilder &fbb_; 5081 flatbuffers::uoffset_t start_; 5082 explicit ExpOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5083 : fbb_(_fbb) { 5084 start_ = fbb_.StartTable(); 5085 } 5086 ExpOptionsBuilder &operator=(const ExpOptionsBuilder &); 5087 flatbuffers::Offset<ExpOptions> Finish() { 5088 const auto end = fbb_.EndTable(start_); 5089 auto o = flatbuffers::Offset<ExpOptions>(end); 5090 return o; 5091 } 5092 }; 5093 5094 inline flatbuffers::Offset<ExpOptions> CreateExpOptions( 5095 flatbuffers::FlatBufferBuilder &_fbb) { 5096 ExpOptionsBuilder builder_(_fbb); 5097 return builder_.Finish(); 5098 } 5099 5100 flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5101 5102 struct CosOptionsT : public flatbuffers::NativeTable { 5103 typedef CosOptions TableType; 5104 CosOptionsT() { 5105 } 5106 }; 5107 5108 struct CosOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5109 typedef CosOptionsT NativeTableType; 5110 bool Verify(flatbuffers::Verifier &verifier) const { 5111 return VerifyTableStart(verifier) && 5112 verifier.EndTable(); 5113 } 5114 CosOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5115 void UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5116 static flatbuffers::Offset<CosOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5117 }; 5118 5119 struct CosOptionsBuilder { 5120 flatbuffers::FlatBufferBuilder &fbb_; 5121 flatbuffers::uoffset_t start_; 5122 explicit CosOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5123 : fbb_(_fbb) { 5124 start_ = fbb_.StartTable(); 5125 } 5126 CosOptionsBuilder &operator=(const CosOptionsBuilder &); 5127 flatbuffers::Offset<CosOptions> Finish() { 5128 const auto end = fbb_.EndTable(start_); 5129 auto o = flatbuffers::Offset<CosOptions>(end); 5130 return o; 5131 } 5132 }; 5133 5134 inline flatbuffers::Offset<CosOptions> CreateCosOptions( 5135 flatbuffers::FlatBufferBuilder &_fbb) { 5136 CosOptionsBuilder builder_(_fbb); 5137 return builder_.Finish(); 5138 } 5139 5140 flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5141 5142 struct ReducerOptionsT : public flatbuffers::NativeTable { 5143 typedef ReducerOptions TableType; 5144 bool keep_dims; 5145 ReducerOptionsT() 5146 : keep_dims(false) { 5147 } 5148 }; 5149 5150 struct ReducerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5151 typedef ReducerOptionsT NativeTableType; 5152 enum { 5153 VT_KEEP_DIMS = 4 5154 }; 5155 bool keep_dims() const { 5156 return GetField<uint8_t>(VT_KEEP_DIMS, 0) != 0; 5157 } 5158 bool Verify(flatbuffers::Verifier &verifier) const { 5159 return VerifyTableStart(verifier) && 5160 VerifyField<uint8_t>(verifier, VT_KEEP_DIMS) && 5161 verifier.EndTable(); 5162 } 5163 ReducerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5164 void UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5165 static flatbuffers::Offset<ReducerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5166 }; 5167 5168 struct ReducerOptionsBuilder { 5169 flatbuffers::FlatBufferBuilder &fbb_; 5170 flatbuffers::uoffset_t start_; 5171 void add_keep_dims(bool keep_dims) { 5172 fbb_.AddElement<uint8_t>(ReducerOptions::VT_KEEP_DIMS, static_cast<uint8_t>(keep_dims), 0); 5173 } 5174 explicit ReducerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5175 : fbb_(_fbb) { 5176 start_ = fbb_.StartTable(); 5177 } 5178 ReducerOptionsBuilder &operator=(const ReducerOptionsBuilder &); 5179 flatbuffers::Offset<ReducerOptions> Finish() { 5180 const auto end = fbb_.EndTable(start_); 5181 auto o = flatbuffers::Offset<ReducerOptions>(end); 5182 return o; 5183 } 5184 }; 5185 5186 inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions( 5187 flatbuffers::FlatBufferBuilder &_fbb, 5188 bool keep_dims = false) { 5189 ReducerOptionsBuilder builder_(_fbb); 5190 builder_.add_keep_dims(keep_dims); 5191 return builder_.Finish(); 5192 } 5193 5194 flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5195 5196 struct SqueezeOptionsT : public flatbuffers::NativeTable { 5197 typedef SqueezeOptions TableType; 5198 std::vector<int32_t> squeeze_dims; 5199 SqueezeOptionsT() { 5200 } 5201 }; 5202 5203 struct SqueezeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5204 typedef SqueezeOptionsT NativeTableType; 5205 enum { 5206 VT_SQUEEZE_DIMS = 4 5207 }; 5208 const flatbuffers::Vector<int32_t> *squeeze_dims() const { 5209 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SQUEEZE_DIMS); 5210 } 5211 bool Verify(flatbuffers::Verifier &verifier) const { 5212 return VerifyTableStart(verifier) && 5213 VerifyOffset(verifier, VT_SQUEEZE_DIMS) && 5214 verifier.VerifyVector(squeeze_dims()) && 5215 verifier.EndTable(); 5216 } 5217 SqueezeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5218 void UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5219 static flatbuffers::Offset<SqueezeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5220 }; 5221 5222 struct SqueezeOptionsBuilder { 5223 flatbuffers::FlatBufferBuilder &fbb_; 5224 flatbuffers::uoffset_t start_; 5225 void add_squeeze_dims(flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims) { 5226 fbb_.AddOffset(SqueezeOptions::VT_SQUEEZE_DIMS, squeeze_dims); 5227 } 5228 explicit SqueezeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5229 : fbb_(_fbb) { 5230 start_ = fbb_.StartTable(); 5231 } 5232 SqueezeOptionsBuilder &operator=(const SqueezeOptionsBuilder &); 5233 flatbuffers::Offset<SqueezeOptions> Finish() { 5234 const auto end = fbb_.EndTable(start_); 5235 auto o = flatbuffers::Offset<SqueezeOptions>(end); 5236 return o; 5237 } 5238 }; 5239 5240 inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions( 5241 flatbuffers::FlatBufferBuilder &_fbb, 5242 flatbuffers::Offset<flatbuffers::Vector<int32_t>> squeeze_dims = 0) { 5243 SqueezeOptionsBuilder builder_(_fbb); 5244 builder_.add_squeeze_dims(squeeze_dims); 5245 return builder_.Finish(); 5246 } 5247 5248 inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptionsDirect( 5249 flatbuffers::FlatBufferBuilder &_fbb, 5250 const std::vector<int32_t> *squeeze_dims = nullptr) { 5251 return tflite::CreateSqueezeOptions( 5252 _fbb, 5253 squeeze_dims ? _fbb.CreateVector<int32_t>(*squeeze_dims) : 0); 5254 } 5255 5256 flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5257 5258 struct SplitOptionsT : public flatbuffers::NativeTable { 5259 typedef SplitOptions TableType; 5260 int32_t num_splits; 5261 SplitOptionsT() 5262 : num_splits(0) { 5263 } 5264 }; 5265 5266 struct SplitOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5267 typedef SplitOptionsT NativeTableType; 5268 enum { 5269 VT_NUM_SPLITS = 4 5270 }; 5271 int32_t num_splits() const { 5272 return GetField<int32_t>(VT_NUM_SPLITS, 0); 5273 } 5274 bool Verify(flatbuffers::Verifier &verifier) const { 5275 return VerifyTableStart(verifier) && 5276 VerifyField<int32_t>(verifier, VT_NUM_SPLITS) && 5277 verifier.EndTable(); 5278 } 5279 SplitOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5280 void UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5281 static flatbuffers::Offset<SplitOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5282 }; 5283 5284 struct SplitOptionsBuilder { 5285 flatbuffers::FlatBufferBuilder &fbb_; 5286 flatbuffers::uoffset_t start_; 5287 void add_num_splits(int32_t num_splits) { 5288 fbb_.AddElement<int32_t>(SplitOptions::VT_NUM_SPLITS, num_splits, 0); 5289 } 5290 explicit SplitOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5291 : fbb_(_fbb) { 5292 start_ = fbb_.StartTable(); 5293 } 5294 SplitOptionsBuilder &operator=(const SplitOptionsBuilder &); 5295 flatbuffers::Offset<SplitOptions> Finish() { 5296 const auto end = fbb_.EndTable(start_); 5297 auto o = flatbuffers::Offset<SplitOptions>(end); 5298 return o; 5299 } 5300 }; 5301 5302 inline flatbuffers::Offset<SplitOptions> CreateSplitOptions( 5303 flatbuffers::FlatBufferBuilder &_fbb, 5304 int32_t num_splits = 0) { 5305 SplitOptionsBuilder builder_(_fbb); 5306 builder_.add_num_splits(num_splits); 5307 return builder_.Finish(); 5308 } 5309 5310 flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5311 5312 struct SplitVOptionsT : public flatbuffers::NativeTable { 5313 typedef SplitVOptions TableType; 5314 int32_t num_splits; 5315 SplitVOptionsT() 5316 : num_splits(0) { 5317 } 5318 }; 5319 5320 struct SplitVOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5321 typedef SplitVOptionsT NativeTableType; 5322 enum { 5323 VT_NUM_SPLITS = 4 5324 }; 5325 int32_t num_splits() const { 5326 return GetField<int32_t>(VT_NUM_SPLITS, 0); 5327 } 5328 bool Verify(flatbuffers::Verifier &verifier) const { 5329 return VerifyTableStart(verifier) && 5330 VerifyField<int32_t>(verifier, VT_NUM_SPLITS) && 5331 verifier.EndTable(); 5332 } 5333 SplitVOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5334 void UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5335 static flatbuffers::Offset<SplitVOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5336 }; 5337 5338 struct SplitVOptionsBuilder { 5339 flatbuffers::FlatBufferBuilder &fbb_; 5340 flatbuffers::uoffset_t start_; 5341 void add_num_splits(int32_t num_splits) { 5342 fbb_.AddElement<int32_t>(SplitVOptions::VT_NUM_SPLITS, num_splits, 0); 5343 } 5344 explicit SplitVOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5345 : fbb_(_fbb) { 5346 start_ = fbb_.StartTable(); 5347 } 5348 SplitVOptionsBuilder &operator=(const SplitVOptionsBuilder &); 5349 flatbuffers::Offset<SplitVOptions> Finish() { 5350 const auto end = fbb_.EndTable(start_); 5351 auto o = flatbuffers::Offset<SplitVOptions>(end); 5352 return o; 5353 } 5354 }; 5355 5356 inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions( 5357 flatbuffers::FlatBufferBuilder &_fbb, 5358 int32_t num_splits = 0) { 5359 SplitVOptionsBuilder builder_(_fbb); 5360 builder_.add_num_splits(num_splits); 5361 return builder_.Finish(); 5362 } 5363 5364 flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5365 5366 struct StridedSliceOptionsT : public flatbuffers::NativeTable { 5367 typedef StridedSliceOptions TableType; 5368 int32_t begin_mask; 5369 int32_t end_mask; 5370 int32_t ellipsis_mask; 5371 int32_t new_axis_mask; 5372 int32_t shrink_axis_mask; 5373 StridedSliceOptionsT() 5374 : begin_mask(0), 5375 end_mask(0), 5376 ellipsis_mask(0), 5377 new_axis_mask(0), 5378 shrink_axis_mask(0) { 5379 } 5380 }; 5381 5382 struct StridedSliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5383 typedef StridedSliceOptionsT NativeTableType; 5384 enum { 5385 VT_BEGIN_MASK = 4, 5386 VT_END_MASK = 6, 5387 VT_ELLIPSIS_MASK = 8, 5388 VT_NEW_AXIS_MASK = 10, 5389 VT_SHRINK_AXIS_MASK = 12 5390 }; 5391 int32_t begin_mask() const { 5392 return GetField<int32_t>(VT_BEGIN_MASK, 0); 5393 } 5394 int32_t end_mask() const { 5395 return GetField<int32_t>(VT_END_MASK, 0); 5396 } 5397 int32_t ellipsis_mask() const { 5398 return GetField<int32_t>(VT_ELLIPSIS_MASK, 0); 5399 } 5400 int32_t new_axis_mask() const { 5401 return GetField<int32_t>(VT_NEW_AXIS_MASK, 0); 5402 } 5403 int32_t shrink_axis_mask() const { 5404 return GetField<int32_t>(VT_SHRINK_AXIS_MASK, 0); 5405 } 5406 bool Verify(flatbuffers::Verifier &verifier) const { 5407 return VerifyTableStart(verifier) && 5408 VerifyField<int32_t>(verifier, VT_BEGIN_MASK) && 5409 VerifyField<int32_t>(verifier, VT_END_MASK) && 5410 VerifyField<int32_t>(verifier, VT_ELLIPSIS_MASK) && 5411 VerifyField<int32_t>(verifier, VT_NEW_AXIS_MASK) && 5412 VerifyField<int32_t>(verifier, VT_SHRINK_AXIS_MASK) && 5413 verifier.EndTable(); 5414 } 5415 StridedSliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5416 void UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5417 static flatbuffers::Offset<StridedSliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5418 }; 5419 5420 struct StridedSliceOptionsBuilder { 5421 flatbuffers::FlatBufferBuilder &fbb_; 5422 flatbuffers::uoffset_t start_; 5423 void add_begin_mask(int32_t begin_mask) { 5424 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_BEGIN_MASK, begin_mask, 0); 5425 } 5426 void add_end_mask(int32_t end_mask) { 5427 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_END_MASK, end_mask, 0); 5428 } 5429 void add_ellipsis_mask(int32_t ellipsis_mask) { 5430 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_ELLIPSIS_MASK, ellipsis_mask, 0); 5431 } 5432 void add_new_axis_mask(int32_t new_axis_mask) { 5433 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_NEW_AXIS_MASK, new_axis_mask, 0); 5434 } 5435 void add_shrink_axis_mask(int32_t shrink_axis_mask) { 5436 fbb_.AddElement<int32_t>(StridedSliceOptions::VT_SHRINK_AXIS_MASK, shrink_axis_mask, 0); 5437 } 5438 explicit StridedSliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5439 : fbb_(_fbb) { 5440 start_ = fbb_.StartTable(); 5441 } 5442 StridedSliceOptionsBuilder &operator=(const StridedSliceOptionsBuilder &); 5443 flatbuffers::Offset<StridedSliceOptions> Finish() { 5444 const auto end = fbb_.EndTable(start_); 5445 auto o = flatbuffers::Offset<StridedSliceOptions>(end); 5446 return o; 5447 } 5448 }; 5449 5450 inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions( 5451 flatbuffers::FlatBufferBuilder &_fbb, 5452 int32_t begin_mask = 0, 5453 int32_t end_mask = 0, 5454 int32_t ellipsis_mask = 0, 5455 int32_t new_axis_mask = 0, 5456 int32_t shrink_axis_mask = 0) { 5457 StridedSliceOptionsBuilder builder_(_fbb); 5458 builder_.add_shrink_axis_mask(shrink_axis_mask); 5459 builder_.add_new_axis_mask(new_axis_mask); 5460 builder_.add_ellipsis_mask(ellipsis_mask); 5461 builder_.add_end_mask(end_mask); 5462 builder_.add_begin_mask(begin_mask); 5463 return builder_.Finish(); 5464 } 5465 5466 flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5467 5468 struct LogSoftmaxOptionsT : public flatbuffers::NativeTable { 5469 typedef LogSoftmaxOptions TableType; 5470 LogSoftmaxOptionsT() { 5471 } 5472 }; 5473 5474 struct LogSoftmaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5475 typedef LogSoftmaxOptionsT NativeTableType; 5476 bool Verify(flatbuffers::Verifier &verifier) const { 5477 return VerifyTableStart(verifier) && 5478 verifier.EndTable(); 5479 } 5480 LogSoftmaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5481 void UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5482 static flatbuffers::Offset<LogSoftmaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5483 }; 5484 5485 struct LogSoftmaxOptionsBuilder { 5486 flatbuffers::FlatBufferBuilder &fbb_; 5487 flatbuffers::uoffset_t start_; 5488 explicit LogSoftmaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5489 : fbb_(_fbb) { 5490 start_ = fbb_.StartTable(); 5491 } 5492 LogSoftmaxOptionsBuilder &operator=(const LogSoftmaxOptionsBuilder &); 5493 flatbuffers::Offset<LogSoftmaxOptions> Finish() { 5494 const auto end = fbb_.EndTable(start_); 5495 auto o = flatbuffers::Offset<LogSoftmaxOptions>(end); 5496 return o; 5497 } 5498 }; 5499 5500 inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions( 5501 flatbuffers::FlatBufferBuilder &_fbb) { 5502 LogSoftmaxOptionsBuilder builder_(_fbb); 5503 return builder_.Finish(); 5504 } 5505 5506 flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5507 5508 struct CastOptionsT : public flatbuffers::NativeTable { 5509 typedef CastOptions TableType; 5510 TensorType in_data_type; 5511 TensorType out_data_type; 5512 CastOptionsT() 5513 : in_data_type(TensorType_FLOAT32), 5514 out_data_type(TensorType_FLOAT32) { 5515 } 5516 }; 5517 5518 struct CastOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5519 typedef CastOptionsT NativeTableType; 5520 enum { 5521 VT_IN_DATA_TYPE = 4, 5522 VT_OUT_DATA_TYPE = 6 5523 }; 5524 TensorType in_data_type() const { 5525 return static_cast<TensorType>(GetField<int8_t>(VT_IN_DATA_TYPE, 0)); 5526 } 5527 TensorType out_data_type() const { 5528 return static_cast<TensorType>(GetField<int8_t>(VT_OUT_DATA_TYPE, 0)); 5529 } 5530 bool Verify(flatbuffers::Verifier &verifier) const { 5531 return VerifyTableStart(verifier) && 5532 VerifyField<int8_t>(verifier, VT_IN_DATA_TYPE) && 5533 VerifyField<int8_t>(verifier, VT_OUT_DATA_TYPE) && 5534 verifier.EndTable(); 5535 } 5536 CastOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5537 void UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5538 static flatbuffers::Offset<CastOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5539 }; 5540 5541 struct CastOptionsBuilder { 5542 flatbuffers::FlatBufferBuilder &fbb_; 5543 flatbuffers::uoffset_t start_; 5544 void add_in_data_type(TensorType in_data_type) { 5545 fbb_.AddElement<int8_t>(CastOptions::VT_IN_DATA_TYPE, static_cast<int8_t>(in_data_type), 0); 5546 } 5547 void add_out_data_type(TensorType out_data_type) { 5548 fbb_.AddElement<int8_t>(CastOptions::VT_OUT_DATA_TYPE, static_cast<int8_t>(out_data_type), 0); 5549 } 5550 explicit CastOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5551 : fbb_(_fbb) { 5552 start_ = fbb_.StartTable(); 5553 } 5554 CastOptionsBuilder &operator=(const CastOptionsBuilder &); 5555 flatbuffers::Offset<CastOptions> Finish() { 5556 const auto end = fbb_.EndTable(start_); 5557 auto o = flatbuffers::Offset<CastOptions>(end); 5558 return o; 5559 } 5560 }; 5561 5562 inline flatbuffers::Offset<CastOptions> CreateCastOptions( 5563 flatbuffers::FlatBufferBuilder &_fbb, 5564 TensorType in_data_type = TensorType_FLOAT32, 5565 TensorType out_data_type = TensorType_FLOAT32) { 5566 CastOptionsBuilder builder_(_fbb); 5567 builder_.add_out_data_type(out_data_type); 5568 builder_.add_in_data_type(in_data_type); 5569 return builder_.Finish(); 5570 } 5571 5572 flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5573 5574 struct DequantizeOptionsT : public flatbuffers::NativeTable { 5575 typedef DequantizeOptions TableType; 5576 DequantizeOptionsT() { 5577 } 5578 }; 5579 5580 struct DequantizeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5581 typedef DequantizeOptionsT NativeTableType; 5582 bool Verify(flatbuffers::Verifier &verifier) const { 5583 return VerifyTableStart(verifier) && 5584 verifier.EndTable(); 5585 } 5586 DequantizeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5587 void UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5588 static flatbuffers::Offset<DequantizeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5589 }; 5590 5591 struct DequantizeOptionsBuilder { 5592 flatbuffers::FlatBufferBuilder &fbb_; 5593 flatbuffers::uoffset_t start_; 5594 explicit DequantizeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5595 : fbb_(_fbb) { 5596 start_ = fbb_.StartTable(); 5597 } 5598 DequantizeOptionsBuilder &operator=(const DequantizeOptionsBuilder &); 5599 flatbuffers::Offset<DequantizeOptions> Finish() { 5600 const auto end = fbb_.EndTable(start_); 5601 auto o = flatbuffers::Offset<DequantizeOptions>(end); 5602 return o; 5603 } 5604 }; 5605 5606 inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions( 5607 flatbuffers::FlatBufferBuilder &_fbb) { 5608 DequantizeOptionsBuilder builder_(_fbb); 5609 return builder_.Finish(); 5610 } 5611 5612 flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5613 5614 struct MaximumMinimumOptionsT : public flatbuffers::NativeTable { 5615 typedef MaximumMinimumOptions TableType; 5616 MaximumMinimumOptionsT() { 5617 } 5618 }; 5619 5620 struct MaximumMinimumOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5621 typedef MaximumMinimumOptionsT NativeTableType; 5622 bool Verify(flatbuffers::Verifier &verifier) const { 5623 return VerifyTableStart(verifier) && 5624 verifier.EndTable(); 5625 } 5626 MaximumMinimumOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5627 void UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5628 static flatbuffers::Offset<MaximumMinimumOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5629 }; 5630 5631 struct MaximumMinimumOptionsBuilder { 5632 flatbuffers::FlatBufferBuilder &fbb_; 5633 flatbuffers::uoffset_t start_; 5634 explicit MaximumMinimumOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5635 : fbb_(_fbb) { 5636 start_ = fbb_.StartTable(); 5637 } 5638 MaximumMinimumOptionsBuilder &operator=(const MaximumMinimumOptionsBuilder &); 5639 flatbuffers::Offset<MaximumMinimumOptions> Finish() { 5640 const auto end = fbb_.EndTable(start_); 5641 auto o = flatbuffers::Offset<MaximumMinimumOptions>(end); 5642 return o; 5643 } 5644 }; 5645 5646 inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions( 5647 flatbuffers::FlatBufferBuilder &_fbb) { 5648 MaximumMinimumOptionsBuilder builder_(_fbb); 5649 return builder_.Finish(); 5650 } 5651 5652 flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5653 5654 struct TileOptionsT : public flatbuffers::NativeTable { 5655 typedef TileOptions TableType; 5656 TileOptionsT() { 5657 } 5658 }; 5659 5660 struct TileOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5661 typedef TileOptionsT NativeTableType; 5662 bool Verify(flatbuffers::Verifier &verifier) const { 5663 return VerifyTableStart(verifier) && 5664 verifier.EndTable(); 5665 } 5666 TileOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5667 void UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5668 static flatbuffers::Offset<TileOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5669 }; 5670 5671 struct TileOptionsBuilder { 5672 flatbuffers::FlatBufferBuilder &fbb_; 5673 flatbuffers::uoffset_t start_; 5674 explicit TileOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5675 : fbb_(_fbb) { 5676 start_ = fbb_.StartTable(); 5677 } 5678 TileOptionsBuilder &operator=(const TileOptionsBuilder &); 5679 flatbuffers::Offset<TileOptions> Finish() { 5680 const auto end = fbb_.EndTable(start_); 5681 auto o = flatbuffers::Offset<TileOptions>(end); 5682 return o; 5683 } 5684 }; 5685 5686 inline flatbuffers::Offset<TileOptions> CreateTileOptions( 5687 flatbuffers::FlatBufferBuilder &_fbb) { 5688 TileOptionsBuilder builder_(_fbb); 5689 return builder_.Finish(); 5690 } 5691 5692 flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5693 5694 struct ArgMaxOptionsT : public flatbuffers::NativeTable { 5695 typedef ArgMaxOptions TableType; 5696 TensorType output_type; 5697 ArgMaxOptionsT() 5698 : output_type(TensorType_FLOAT32) { 5699 } 5700 }; 5701 5702 struct ArgMaxOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5703 typedef ArgMaxOptionsT NativeTableType; 5704 enum { 5705 VT_OUTPUT_TYPE = 4 5706 }; 5707 TensorType output_type() const { 5708 return static_cast<TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0)); 5709 } 5710 bool Verify(flatbuffers::Verifier &verifier) const { 5711 return VerifyTableStart(verifier) && 5712 VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) && 5713 verifier.EndTable(); 5714 } 5715 ArgMaxOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5716 void UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5717 static flatbuffers::Offset<ArgMaxOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5718 }; 5719 5720 struct ArgMaxOptionsBuilder { 5721 flatbuffers::FlatBufferBuilder &fbb_; 5722 flatbuffers::uoffset_t start_; 5723 void add_output_type(TensorType output_type) { 5724 fbb_.AddElement<int8_t>(ArgMaxOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0); 5725 } 5726 explicit ArgMaxOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5727 : fbb_(_fbb) { 5728 start_ = fbb_.StartTable(); 5729 } 5730 ArgMaxOptionsBuilder &operator=(const ArgMaxOptionsBuilder &); 5731 flatbuffers::Offset<ArgMaxOptions> Finish() { 5732 const auto end = fbb_.EndTable(start_); 5733 auto o = flatbuffers::Offset<ArgMaxOptions>(end); 5734 return o; 5735 } 5736 }; 5737 5738 inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions( 5739 flatbuffers::FlatBufferBuilder &_fbb, 5740 TensorType output_type = TensorType_FLOAT32) { 5741 ArgMaxOptionsBuilder builder_(_fbb); 5742 builder_.add_output_type(output_type); 5743 return builder_.Finish(); 5744 } 5745 5746 flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5747 5748 struct ArgMinOptionsT : public flatbuffers::NativeTable { 5749 typedef ArgMinOptions TableType; 5750 TensorType output_type; 5751 ArgMinOptionsT() 5752 : output_type(TensorType_FLOAT32) { 5753 } 5754 }; 5755 5756 struct ArgMinOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5757 typedef ArgMinOptionsT NativeTableType; 5758 enum { 5759 VT_OUTPUT_TYPE = 4 5760 }; 5761 TensorType output_type() const { 5762 return static_cast<TensorType>(GetField<int8_t>(VT_OUTPUT_TYPE, 0)); 5763 } 5764 bool Verify(flatbuffers::Verifier &verifier) const { 5765 return VerifyTableStart(verifier) && 5766 VerifyField<int8_t>(verifier, VT_OUTPUT_TYPE) && 5767 verifier.EndTable(); 5768 } 5769 ArgMinOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5770 void UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5771 static flatbuffers::Offset<ArgMinOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5772 }; 5773 5774 struct ArgMinOptionsBuilder { 5775 flatbuffers::FlatBufferBuilder &fbb_; 5776 flatbuffers::uoffset_t start_; 5777 void add_output_type(TensorType output_type) { 5778 fbb_.AddElement<int8_t>(ArgMinOptions::VT_OUTPUT_TYPE, static_cast<int8_t>(output_type), 0); 5779 } 5780 explicit ArgMinOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5781 : fbb_(_fbb) { 5782 start_ = fbb_.StartTable(); 5783 } 5784 ArgMinOptionsBuilder &operator=(const ArgMinOptionsBuilder &); 5785 flatbuffers::Offset<ArgMinOptions> Finish() { 5786 const auto end = fbb_.EndTable(start_); 5787 auto o = flatbuffers::Offset<ArgMinOptions>(end); 5788 return o; 5789 } 5790 }; 5791 5792 inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions( 5793 flatbuffers::FlatBufferBuilder &_fbb, 5794 TensorType output_type = TensorType_FLOAT32) { 5795 ArgMinOptionsBuilder builder_(_fbb); 5796 builder_.add_output_type(output_type); 5797 return builder_.Finish(); 5798 } 5799 5800 flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5801 5802 struct GreaterOptionsT : public flatbuffers::NativeTable { 5803 typedef GreaterOptions TableType; 5804 GreaterOptionsT() { 5805 } 5806 }; 5807 5808 struct GreaterOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5809 typedef GreaterOptionsT NativeTableType; 5810 bool Verify(flatbuffers::Verifier &verifier) const { 5811 return VerifyTableStart(verifier) && 5812 verifier.EndTable(); 5813 } 5814 GreaterOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5815 void UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5816 static flatbuffers::Offset<GreaterOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5817 }; 5818 5819 struct GreaterOptionsBuilder { 5820 flatbuffers::FlatBufferBuilder &fbb_; 5821 flatbuffers::uoffset_t start_; 5822 explicit GreaterOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5823 : fbb_(_fbb) { 5824 start_ = fbb_.StartTable(); 5825 } 5826 GreaterOptionsBuilder &operator=(const GreaterOptionsBuilder &); 5827 flatbuffers::Offset<GreaterOptions> Finish() { 5828 const auto end = fbb_.EndTable(start_); 5829 auto o = flatbuffers::Offset<GreaterOptions>(end); 5830 return o; 5831 } 5832 }; 5833 5834 inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions( 5835 flatbuffers::FlatBufferBuilder &_fbb) { 5836 GreaterOptionsBuilder builder_(_fbb); 5837 return builder_.Finish(); 5838 } 5839 5840 flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5841 5842 struct GreaterEqualOptionsT : public flatbuffers::NativeTable { 5843 typedef GreaterEqualOptions TableType; 5844 GreaterEqualOptionsT() { 5845 } 5846 }; 5847 5848 struct GreaterEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5849 typedef GreaterEqualOptionsT NativeTableType; 5850 bool Verify(flatbuffers::Verifier &verifier) const { 5851 return VerifyTableStart(verifier) && 5852 verifier.EndTable(); 5853 } 5854 GreaterEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5855 void UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5856 static flatbuffers::Offset<GreaterEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5857 }; 5858 5859 struct GreaterEqualOptionsBuilder { 5860 flatbuffers::FlatBufferBuilder &fbb_; 5861 flatbuffers::uoffset_t start_; 5862 explicit GreaterEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5863 : fbb_(_fbb) { 5864 start_ = fbb_.StartTable(); 5865 } 5866 GreaterEqualOptionsBuilder &operator=(const GreaterEqualOptionsBuilder &); 5867 flatbuffers::Offset<GreaterEqualOptions> Finish() { 5868 const auto end = fbb_.EndTable(start_); 5869 auto o = flatbuffers::Offset<GreaterEqualOptions>(end); 5870 return o; 5871 } 5872 }; 5873 5874 inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions( 5875 flatbuffers::FlatBufferBuilder &_fbb) { 5876 GreaterEqualOptionsBuilder builder_(_fbb); 5877 return builder_.Finish(); 5878 } 5879 5880 flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5881 5882 struct LessOptionsT : public flatbuffers::NativeTable { 5883 typedef LessOptions TableType; 5884 LessOptionsT() { 5885 } 5886 }; 5887 5888 struct LessOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5889 typedef LessOptionsT NativeTableType; 5890 bool Verify(flatbuffers::Verifier &verifier) const { 5891 return VerifyTableStart(verifier) && 5892 verifier.EndTable(); 5893 } 5894 LessOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5895 void UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5896 static flatbuffers::Offset<LessOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5897 }; 5898 5899 struct LessOptionsBuilder { 5900 flatbuffers::FlatBufferBuilder &fbb_; 5901 flatbuffers::uoffset_t start_; 5902 explicit LessOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5903 : fbb_(_fbb) { 5904 start_ = fbb_.StartTable(); 5905 } 5906 LessOptionsBuilder &operator=(const LessOptionsBuilder &); 5907 flatbuffers::Offset<LessOptions> Finish() { 5908 const auto end = fbb_.EndTable(start_); 5909 auto o = flatbuffers::Offset<LessOptions>(end); 5910 return o; 5911 } 5912 }; 5913 5914 inline flatbuffers::Offset<LessOptions> CreateLessOptions( 5915 flatbuffers::FlatBufferBuilder &_fbb) { 5916 LessOptionsBuilder builder_(_fbb); 5917 return builder_.Finish(); 5918 } 5919 5920 flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5921 5922 struct LessEqualOptionsT : public flatbuffers::NativeTable { 5923 typedef LessEqualOptions TableType; 5924 LessEqualOptionsT() { 5925 } 5926 }; 5927 5928 struct LessEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5929 typedef LessEqualOptionsT NativeTableType; 5930 bool Verify(flatbuffers::Verifier &verifier) const { 5931 return VerifyTableStart(verifier) && 5932 verifier.EndTable(); 5933 } 5934 LessEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5935 void UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5936 static flatbuffers::Offset<LessEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5937 }; 5938 5939 struct LessEqualOptionsBuilder { 5940 flatbuffers::FlatBufferBuilder &fbb_; 5941 flatbuffers::uoffset_t start_; 5942 explicit LessEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5943 : fbb_(_fbb) { 5944 start_ = fbb_.StartTable(); 5945 } 5946 LessEqualOptionsBuilder &operator=(const LessEqualOptionsBuilder &); 5947 flatbuffers::Offset<LessEqualOptions> Finish() { 5948 const auto end = fbb_.EndTable(start_); 5949 auto o = flatbuffers::Offset<LessEqualOptions>(end); 5950 return o; 5951 } 5952 }; 5953 5954 inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions( 5955 flatbuffers::FlatBufferBuilder &_fbb) { 5956 LessEqualOptionsBuilder builder_(_fbb); 5957 return builder_.Finish(); 5958 } 5959 5960 flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5961 5962 struct NegOptionsT : public flatbuffers::NativeTable { 5963 typedef NegOptions TableType; 5964 NegOptionsT() { 5965 } 5966 }; 5967 5968 struct NegOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 5969 typedef NegOptionsT NativeTableType; 5970 bool Verify(flatbuffers::Verifier &verifier) const { 5971 return VerifyTableStart(verifier) && 5972 verifier.EndTable(); 5973 } 5974 NegOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5975 void UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 5976 static flatbuffers::Offset<NegOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 5977 }; 5978 5979 struct NegOptionsBuilder { 5980 flatbuffers::FlatBufferBuilder &fbb_; 5981 flatbuffers::uoffset_t start_; 5982 explicit NegOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 5983 : fbb_(_fbb) { 5984 start_ = fbb_.StartTable(); 5985 } 5986 NegOptionsBuilder &operator=(const NegOptionsBuilder &); 5987 flatbuffers::Offset<NegOptions> Finish() { 5988 const auto end = fbb_.EndTable(start_); 5989 auto o = flatbuffers::Offset<NegOptions>(end); 5990 return o; 5991 } 5992 }; 5993 5994 inline flatbuffers::Offset<NegOptions> CreateNegOptions( 5995 flatbuffers::FlatBufferBuilder &_fbb) { 5996 NegOptionsBuilder builder_(_fbb); 5997 return builder_.Finish(); 5998 } 5999 6000 flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6001 6002 struct SelectOptionsT : public flatbuffers::NativeTable { 6003 typedef SelectOptions TableType; 6004 SelectOptionsT() { 6005 } 6006 }; 6007 6008 struct SelectOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6009 typedef SelectOptionsT NativeTableType; 6010 bool Verify(flatbuffers::Verifier &verifier) const { 6011 return VerifyTableStart(verifier) && 6012 verifier.EndTable(); 6013 } 6014 SelectOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6015 void UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6016 static flatbuffers::Offset<SelectOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6017 }; 6018 6019 struct SelectOptionsBuilder { 6020 flatbuffers::FlatBufferBuilder &fbb_; 6021 flatbuffers::uoffset_t start_; 6022 explicit SelectOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6023 : fbb_(_fbb) { 6024 start_ = fbb_.StartTable(); 6025 } 6026 SelectOptionsBuilder &operator=(const SelectOptionsBuilder &); 6027 flatbuffers::Offset<SelectOptions> Finish() { 6028 const auto end = fbb_.EndTable(start_); 6029 auto o = flatbuffers::Offset<SelectOptions>(end); 6030 return o; 6031 } 6032 }; 6033 6034 inline flatbuffers::Offset<SelectOptions> CreateSelectOptions( 6035 flatbuffers::FlatBufferBuilder &_fbb) { 6036 SelectOptionsBuilder builder_(_fbb); 6037 return builder_.Finish(); 6038 } 6039 6040 flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6041 6042 struct SliceOptionsT : public flatbuffers::NativeTable { 6043 typedef SliceOptions TableType; 6044 SliceOptionsT() { 6045 } 6046 }; 6047 6048 struct SliceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6049 typedef SliceOptionsT NativeTableType; 6050 bool Verify(flatbuffers::Verifier &verifier) const { 6051 return VerifyTableStart(verifier) && 6052 verifier.EndTable(); 6053 } 6054 SliceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6055 void UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6056 static flatbuffers::Offset<SliceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6057 }; 6058 6059 struct SliceOptionsBuilder { 6060 flatbuffers::FlatBufferBuilder &fbb_; 6061 flatbuffers::uoffset_t start_; 6062 explicit SliceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6063 : fbb_(_fbb) { 6064 start_ = fbb_.StartTable(); 6065 } 6066 SliceOptionsBuilder &operator=(const SliceOptionsBuilder &); 6067 flatbuffers::Offset<SliceOptions> Finish() { 6068 const auto end = fbb_.EndTable(start_); 6069 auto o = flatbuffers::Offset<SliceOptions>(end); 6070 return o; 6071 } 6072 }; 6073 6074 inline flatbuffers::Offset<SliceOptions> CreateSliceOptions( 6075 flatbuffers::FlatBufferBuilder &_fbb) { 6076 SliceOptionsBuilder builder_(_fbb); 6077 return builder_.Finish(); 6078 } 6079 6080 flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6081 6082 struct TransposeConvOptionsT : public flatbuffers::NativeTable { 6083 typedef TransposeConvOptions TableType; 6084 Padding padding; 6085 int32_t stride_w; 6086 int32_t stride_h; 6087 TransposeConvOptionsT() 6088 : padding(Padding_SAME), 6089 stride_w(0), 6090 stride_h(0) { 6091 } 6092 }; 6093 6094 struct TransposeConvOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6095 typedef TransposeConvOptionsT NativeTableType; 6096 enum { 6097 VT_PADDING = 4, 6098 VT_STRIDE_W = 6, 6099 VT_STRIDE_H = 8 6100 }; 6101 Padding padding() const { 6102 return static_cast<Padding>(GetField<int8_t>(VT_PADDING, 0)); 6103 } 6104 int32_t stride_w() const { 6105 return GetField<int32_t>(VT_STRIDE_W, 0); 6106 } 6107 int32_t stride_h() const { 6108 return GetField<int32_t>(VT_STRIDE_H, 0); 6109 } 6110 bool Verify(flatbuffers::Verifier &verifier) const { 6111 return VerifyTableStart(verifier) && 6112 VerifyField<int8_t>(verifier, VT_PADDING) && 6113 VerifyField<int32_t>(verifier, VT_STRIDE_W) && 6114 VerifyField<int32_t>(verifier, VT_STRIDE_H) && 6115 verifier.EndTable(); 6116 } 6117 TransposeConvOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6118 void UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6119 static flatbuffers::Offset<TransposeConvOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6120 }; 6121 6122 struct TransposeConvOptionsBuilder { 6123 flatbuffers::FlatBufferBuilder &fbb_; 6124 flatbuffers::uoffset_t start_; 6125 void add_padding(Padding padding) { 6126 fbb_.AddElement<int8_t>(TransposeConvOptions::VT_PADDING, static_cast<int8_t>(padding), 0); 6127 } 6128 void add_stride_w(int32_t stride_w) { 6129 fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_W, stride_w, 0); 6130 } 6131 void add_stride_h(int32_t stride_h) { 6132 fbb_.AddElement<int32_t>(TransposeConvOptions::VT_STRIDE_H, stride_h, 0); 6133 } 6134 explicit TransposeConvOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6135 : fbb_(_fbb) { 6136 start_ = fbb_.StartTable(); 6137 } 6138 TransposeConvOptionsBuilder &operator=(const TransposeConvOptionsBuilder &); 6139 flatbuffers::Offset<TransposeConvOptions> Finish() { 6140 const auto end = fbb_.EndTable(start_); 6141 auto o = flatbuffers::Offset<TransposeConvOptions>(end); 6142 return o; 6143 } 6144 }; 6145 6146 inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions( 6147 flatbuffers::FlatBufferBuilder &_fbb, 6148 Padding padding = Padding_SAME, 6149 int32_t stride_w = 0, 6150 int32_t stride_h = 0) { 6151 TransposeConvOptionsBuilder builder_(_fbb); 6152 builder_.add_stride_h(stride_h); 6153 builder_.add_stride_w(stride_w); 6154 builder_.add_padding(padding); 6155 return builder_.Finish(); 6156 } 6157 6158 flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6159 6160 struct ExpandDimsOptionsT : public flatbuffers::NativeTable { 6161 typedef ExpandDimsOptions TableType; 6162 ExpandDimsOptionsT() { 6163 } 6164 }; 6165 6166 struct ExpandDimsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6167 typedef ExpandDimsOptionsT NativeTableType; 6168 bool Verify(flatbuffers::Verifier &verifier) const { 6169 return VerifyTableStart(verifier) && 6170 verifier.EndTable(); 6171 } 6172 ExpandDimsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6173 void UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6174 static flatbuffers::Offset<ExpandDimsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6175 }; 6176 6177 struct ExpandDimsOptionsBuilder { 6178 flatbuffers::FlatBufferBuilder &fbb_; 6179 flatbuffers::uoffset_t start_; 6180 explicit ExpandDimsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6181 : fbb_(_fbb) { 6182 start_ = fbb_.StartTable(); 6183 } 6184 ExpandDimsOptionsBuilder &operator=(const ExpandDimsOptionsBuilder &); 6185 flatbuffers::Offset<ExpandDimsOptions> Finish() { 6186 const auto end = fbb_.EndTable(start_); 6187 auto o = flatbuffers::Offset<ExpandDimsOptions>(end); 6188 return o; 6189 } 6190 }; 6191 6192 inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions( 6193 flatbuffers::FlatBufferBuilder &_fbb) { 6194 ExpandDimsOptionsBuilder builder_(_fbb); 6195 return builder_.Finish(); 6196 } 6197 6198 flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6199 6200 struct SparseToDenseOptionsT : public flatbuffers::NativeTable { 6201 typedef SparseToDenseOptions TableType; 6202 bool validate_indices; 6203 SparseToDenseOptionsT() 6204 : validate_indices(false) { 6205 } 6206 }; 6207 6208 struct SparseToDenseOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6209 typedef SparseToDenseOptionsT NativeTableType; 6210 enum { 6211 VT_VALIDATE_INDICES = 4 6212 }; 6213 bool validate_indices() const { 6214 return GetField<uint8_t>(VT_VALIDATE_INDICES, 0) != 0; 6215 } 6216 bool Verify(flatbuffers::Verifier &verifier) const { 6217 return VerifyTableStart(verifier) && 6218 VerifyField<uint8_t>(verifier, VT_VALIDATE_INDICES) && 6219 verifier.EndTable(); 6220 } 6221 SparseToDenseOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6222 void UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6223 static flatbuffers::Offset<SparseToDenseOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6224 }; 6225 6226 struct SparseToDenseOptionsBuilder { 6227 flatbuffers::FlatBufferBuilder &fbb_; 6228 flatbuffers::uoffset_t start_; 6229 void add_validate_indices(bool validate_indices) { 6230 fbb_.AddElement<uint8_t>(SparseToDenseOptions::VT_VALIDATE_INDICES, static_cast<uint8_t>(validate_indices), 0); 6231 } 6232 explicit SparseToDenseOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6233 : fbb_(_fbb) { 6234 start_ = fbb_.StartTable(); 6235 } 6236 SparseToDenseOptionsBuilder &operator=(const SparseToDenseOptionsBuilder &); 6237 flatbuffers::Offset<SparseToDenseOptions> Finish() { 6238 const auto end = fbb_.EndTable(start_); 6239 auto o = flatbuffers::Offset<SparseToDenseOptions>(end); 6240 return o; 6241 } 6242 }; 6243 6244 inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions( 6245 flatbuffers::FlatBufferBuilder &_fbb, 6246 bool validate_indices = false) { 6247 SparseToDenseOptionsBuilder builder_(_fbb); 6248 builder_.add_validate_indices(validate_indices); 6249 return builder_.Finish(); 6250 } 6251 6252 flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6253 6254 struct EqualOptionsT : public flatbuffers::NativeTable { 6255 typedef EqualOptions TableType; 6256 EqualOptionsT() { 6257 } 6258 }; 6259 6260 struct EqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6261 typedef EqualOptionsT NativeTableType; 6262 bool Verify(flatbuffers::Verifier &verifier) const { 6263 return VerifyTableStart(verifier) && 6264 verifier.EndTable(); 6265 } 6266 EqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6267 void UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6268 static flatbuffers::Offset<EqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6269 }; 6270 6271 struct EqualOptionsBuilder { 6272 flatbuffers::FlatBufferBuilder &fbb_; 6273 flatbuffers::uoffset_t start_; 6274 explicit EqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6275 : fbb_(_fbb) { 6276 start_ = fbb_.StartTable(); 6277 } 6278 EqualOptionsBuilder &operator=(const EqualOptionsBuilder &); 6279 flatbuffers::Offset<EqualOptions> Finish() { 6280 const auto end = fbb_.EndTable(start_); 6281 auto o = flatbuffers::Offset<EqualOptions>(end); 6282 return o; 6283 } 6284 }; 6285 6286 inline flatbuffers::Offset<EqualOptions> CreateEqualOptions( 6287 flatbuffers::FlatBufferBuilder &_fbb) { 6288 EqualOptionsBuilder builder_(_fbb); 6289 return builder_.Finish(); 6290 } 6291 6292 flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6293 6294 struct NotEqualOptionsT : public flatbuffers::NativeTable { 6295 typedef NotEqualOptions TableType; 6296 NotEqualOptionsT() { 6297 } 6298 }; 6299 6300 struct NotEqualOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6301 typedef NotEqualOptionsT NativeTableType; 6302 bool Verify(flatbuffers::Verifier &verifier) const { 6303 return VerifyTableStart(verifier) && 6304 verifier.EndTable(); 6305 } 6306 NotEqualOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6307 void UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6308 static flatbuffers::Offset<NotEqualOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6309 }; 6310 6311 struct NotEqualOptionsBuilder { 6312 flatbuffers::FlatBufferBuilder &fbb_; 6313 flatbuffers::uoffset_t start_; 6314 explicit NotEqualOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6315 : fbb_(_fbb) { 6316 start_ = fbb_.StartTable(); 6317 } 6318 NotEqualOptionsBuilder &operator=(const NotEqualOptionsBuilder &); 6319 flatbuffers::Offset<NotEqualOptions> Finish() { 6320 const auto end = fbb_.EndTable(start_); 6321 auto o = flatbuffers::Offset<NotEqualOptions>(end); 6322 return o; 6323 } 6324 }; 6325 6326 inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions( 6327 flatbuffers::FlatBufferBuilder &_fbb) { 6328 NotEqualOptionsBuilder builder_(_fbb); 6329 return builder_.Finish(); 6330 } 6331 6332 flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6333 6334 struct ShapeOptionsT : public flatbuffers::NativeTable { 6335 typedef ShapeOptions TableType; 6336 TensorType out_type; 6337 ShapeOptionsT() 6338 : out_type(TensorType_FLOAT32) { 6339 } 6340 }; 6341 6342 struct ShapeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6343 typedef ShapeOptionsT NativeTableType; 6344 enum { 6345 VT_OUT_TYPE = 4 6346 }; 6347 TensorType out_type() const { 6348 return static_cast<TensorType>(GetField<int8_t>(VT_OUT_TYPE, 0)); 6349 } 6350 bool Verify(flatbuffers::Verifier &verifier) const { 6351 return VerifyTableStart(verifier) && 6352 VerifyField<int8_t>(verifier, VT_OUT_TYPE) && 6353 verifier.EndTable(); 6354 } 6355 ShapeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6356 void UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6357 static flatbuffers::Offset<ShapeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6358 }; 6359 6360 struct ShapeOptionsBuilder { 6361 flatbuffers::FlatBufferBuilder &fbb_; 6362 flatbuffers::uoffset_t start_; 6363 void add_out_type(TensorType out_type) { 6364 fbb_.AddElement<int8_t>(ShapeOptions::VT_OUT_TYPE, static_cast<int8_t>(out_type), 0); 6365 } 6366 explicit ShapeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6367 : fbb_(_fbb) { 6368 start_ = fbb_.StartTable(); 6369 } 6370 ShapeOptionsBuilder &operator=(const ShapeOptionsBuilder &); 6371 flatbuffers::Offset<ShapeOptions> Finish() { 6372 const auto end = fbb_.EndTable(start_); 6373 auto o = flatbuffers::Offset<ShapeOptions>(end); 6374 return o; 6375 } 6376 }; 6377 6378 inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions( 6379 flatbuffers::FlatBufferBuilder &_fbb, 6380 TensorType out_type = TensorType_FLOAT32) { 6381 ShapeOptionsBuilder builder_(_fbb); 6382 builder_.add_out_type(out_type); 6383 return builder_.Finish(); 6384 } 6385 6386 flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6387 6388 struct RankOptionsT : public flatbuffers::NativeTable { 6389 typedef RankOptions TableType; 6390 RankOptionsT() { 6391 } 6392 }; 6393 6394 struct RankOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6395 typedef RankOptionsT NativeTableType; 6396 bool Verify(flatbuffers::Verifier &verifier) const { 6397 return VerifyTableStart(verifier) && 6398 verifier.EndTable(); 6399 } 6400 RankOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6401 void UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6402 static flatbuffers::Offset<RankOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6403 }; 6404 6405 struct RankOptionsBuilder { 6406 flatbuffers::FlatBufferBuilder &fbb_; 6407 flatbuffers::uoffset_t start_; 6408 explicit RankOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6409 : fbb_(_fbb) { 6410 start_ = fbb_.StartTable(); 6411 } 6412 RankOptionsBuilder &operator=(const RankOptionsBuilder &); 6413 flatbuffers::Offset<RankOptions> Finish() { 6414 const auto end = fbb_.EndTable(start_); 6415 auto o = flatbuffers::Offset<RankOptions>(end); 6416 return o; 6417 } 6418 }; 6419 6420 inline flatbuffers::Offset<RankOptions> CreateRankOptions( 6421 flatbuffers::FlatBufferBuilder &_fbb) { 6422 RankOptionsBuilder builder_(_fbb); 6423 return builder_.Finish(); 6424 } 6425 6426 flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6427 6428 struct PowOptionsT : public flatbuffers::NativeTable { 6429 typedef PowOptions TableType; 6430 PowOptionsT() { 6431 } 6432 }; 6433 6434 struct PowOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6435 typedef PowOptionsT NativeTableType; 6436 bool Verify(flatbuffers::Verifier &verifier) const { 6437 return VerifyTableStart(verifier) && 6438 verifier.EndTable(); 6439 } 6440 PowOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6441 void UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6442 static flatbuffers::Offset<PowOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6443 }; 6444 6445 struct PowOptionsBuilder { 6446 flatbuffers::FlatBufferBuilder &fbb_; 6447 flatbuffers::uoffset_t start_; 6448 explicit PowOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6449 : fbb_(_fbb) { 6450 start_ = fbb_.StartTable(); 6451 } 6452 PowOptionsBuilder &operator=(const PowOptionsBuilder &); 6453 flatbuffers::Offset<PowOptions> Finish() { 6454 const auto end = fbb_.EndTable(start_); 6455 auto o = flatbuffers::Offset<PowOptions>(end); 6456 return o; 6457 } 6458 }; 6459 6460 inline flatbuffers::Offset<PowOptions> CreatePowOptions( 6461 flatbuffers::FlatBufferBuilder &_fbb) { 6462 PowOptionsBuilder builder_(_fbb); 6463 return builder_.Finish(); 6464 } 6465 6466 flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6467 6468 struct FakeQuantOptionsT : public flatbuffers::NativeTable { 6469 typedef FakeQuantOptions TableType; 6470 float min; 6471 float max; 6472 int32_t num_bits; 6473 bool narrow_range; 6474 FakeQuantOptionsT() 6475 : min(0.0f), 6476 max(0.0f), 6477 num_bits(0), 6478 narrow_range(false) { 6479 } 6480 }; 6481 6482 struct FakeQuantOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6483 typedef FakeQuantOptionsT NativeTableType; 6484 enum { 6485 VT_MIN = 4, 6486 VT_MAX = 6, 6487 VT_NUM_BITS = 8, 6488 VT_NARROW_RANGE = 10 6489 }; 6490 float min() const { 6491 return GetField<float>(VT_MIN, 0.0f); 6492 } 6493 float max() const { 6494 return GetField<float>(VT_MAX, 0.0f); 6495 } 6496 int32_t num_bits() const { 6497 return GetField<int32_t>(VT_NUM_BITS, 0); 6498 } 6499 bool narrow_range() const { 6500 return GetField<uint8_t>(VT_NARROW_RANGE, 0) != 0; 6501 } 6502 bool Verify(flatbuffers::Verifier &verifier) const { 6503 return VerifyTableStart(verifier) && 6504 VerifyField<float>(verifier, VT_MIN) && 6505 VerifyField<float>(verifier, VT_MAX) && 6506 VerifyField<int32_t>(verifier, VT_NUM_BITS) && 6507 VerifyField<uint8_t>(verifier, VT_NARROW_RANGE) && 6508 verifier.EndTable(); 6509 } 6510 FakeQuantOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6511 void UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6512 static flatbuffers::Offset<FakeQuantOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6513 }; 6514 6515 struct FakeQuantOptionsBuilder { 6516 flatbuffers::FlatBufferBuilder &fbb_; 6517 flatbuffers::uoffset_t start_; 6518 void add_min(float min) { 6519 fbb_.AddElement<float>(FakeQuantOptions::VT_MIN, min, 0.0f); 6520 } 6521 void add_max(float max) { 6522 fbb_.AddElement<float>(FakeQuantOptions::VT_MAX, max, 0.0f); 6523 } 6524 void add_num_bits(int32_t num_bits) { 6525 fbb_.AddElement<int32_t>(FakeQuantOptions::VT_NUM_BITS, num_bits, 0); 6526 } 6527 void add_narrow_range(bool narrow_range) { 6528 fbb_.AddElement<uint8_t>(FakeQuantOptions::VT_NARROW_RANGE, static_cast<uint8_t>(narrow_range), 0); 6529 } 6530 explicit FakeQuantOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6531 : fbb_(_fbb) { 6532 start_ = fbb_.StartTable(); 6533 } 6534 FakeQuantOptionsBuilder &operator=(const FakeQuantOptionsBuilder &); 6535 flatbuffers::Offset<FakeQuantOptions> Finish() { 6536 const auto end = fbb_.EndTable(start_); 6537 auto o = flatbuffers::Offset<FakeQuantOptions>(end); 6538 return o; 6539 } 6540 }; 6541 6542 inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions( 6543 flatbuffers::FlatBufferBuilder &_fbb, 6544 float min = 0.0f, 6545 float max = 0.0f, 6546 int32_t num_bits = 0, 6547 bool narrow_range = false) { 6548 FakeQuantOptionsBuilder builder_(_fbb); 6549 builder_.add_num_bits(num_bits); 6550 builder_.add_max(max); 6551 builder_.add_min(min); 6552 builder_.add_narrow_range(narrow_range); 6553 return builder_.Finish(); 6554 } 6555 6556 flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6557 6558 struct PackOptionsT : public flatbuffers::NativeTable { 6559 typedef PackOptions TableType; 6560 int32_t values_count; 6561 int32_t axis; 6562 PackOptionsT() 6563 : values_count(0), 6564 axis(0) { 6565 } 6566 }; 6567 6568 struct PackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6569 typedef PackOptionsT NativeTableType; 6570 enum { 6571 VT_VALUES_COUNT = 4, 6572 VT_AXIS = 6 6573 }; 6574 int32_t values_count() const { 6575 return GetField<int32_t>(VT_VALUES_COUNT, 0); 6576 } 6577 int32_t axis() const { 6578 return GetField<int32_t>(VT_AXIS, 0); 6579 } 6580 bool Verify(flatbuffers::Verifier &verifier) const { 6581 return VerifyTableStart(verifier) && 6582 VerifyField<int32_t>(verifier, VT_VALUES_COUNT) && 6583 VerifyField<int32_t>(verifier, VT_AXIS) && 6584 verifier.EndTable(); 6585 } 6586 PackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6587 void UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6588 static flatbuffers::Offset<PackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6589 }; 6590 6591 struct PackOptionsBuilder { 6592 flatbuffers::FlatBufferBuilder &fbb_; 6593 flatbuffers::uoffset_t start_; 6594 void add_values_count(int32_t values_count) { 6595 fbb_.AddElement<int32_t>(PackOptions::VT_VALUES_COUNT, values_count, 0); 6596 } 6597 void add_axis(int32_t axis) { 6598 fbb_.AddElement<int32_t>(PackOptions::VT_AXIS, axis, 0); 6599 } 6600 explicit PackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6601 : fbb_(_fbb) { 6602 start_ = fbb_.StartTable(); 6603 } 6604 PackOptionsBuilder &operator=(const PackOptionsBuilder &); 6605 flatbuffers::Offset<PackOptions> Finish() { 6606 const auto end = fbb_.EndTable(start_); 6607 auto o = flatbuffers::Offset<PackOptions>(end); 6608 return o; 6609 } 6610 }; 6611 6612 inline flatbuffers::Offset<PackOptions> CreatePackOptions( 6613 flatbuffers::FlatBufferBuilder &_fbb, 6614 int32_t values_count = 0, 6615 int32_t axis = 0) { 6616 PackOptionsBuilder builder_(_fbb); 6617 builder_.add_axis(axis); 6618 builder_.add_values_count(values_count); 6619 return builder_.Finish(); 6620 } 6621 6622 flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6623 6624 struct LogicalOrOptionsT : public flatbuffers::NativeTable { 6625 typedef LogicalOrOptions TableType; 6626 LogicalOrOptionsT() { 6627 } 6628 }; 6629 6630 struct LogicalOrOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6631 typedef LogicalOrOptionsT NativeTableType; 6632 bool Verify(flatbuffers::Verifier &verifier) const { 6633 return VerifyTableStart(verifier) && 6634 verifier.EndTable(); 6635 } 6636 LogicalOrOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6637 void UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6638 static flatbuffers::Offset<LogicalOrOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6639 }; 6640 6641 struct LogicalOrOptionsBuilder { 6642 flatbuffers::FlatBufferBuilder &fbb_; 6643 flatbuffers::uoffset_t start_; 6644 explicit LogicalOrOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6645 : fbb_(_fbb) { 6646 start_ = fbb_.StartTable(); 6647 } 6648 LogicalOrOptionsBuilder &operator=(const LogicalOrOptionsBuilder &); 6649 flatbuffers::Offset<LogicalOrOptions> Finish() { 6650 const auto end = fbb_.EndTable(start_); 6651 auto o = flatbuffers::Offset<LogicalOrOptions>(end); 6652 return o; 6653 } 6654 }; 6655 6656 inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions( 6657 flatbuffers::FlatBufferBuilder &_fbb) { 6658 LogicalOrOptionsBuilder builder_(_fbb); 6659 return builder_.Finish(); 6660 } 6661 6662 flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6663 6664 struct OneHotOptionsT : public flatbuffers::NativeTable { 6665 typedef OneHotOptions TableType; 6666 int32_t axis; 6667 OneHotOptionsT() 6668 : axis(0) { 6669 } 6670 }; 6671 6672 struct OneHotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6673 typedef OneHotOptionsT NativeTableType; 6674 enum { 6675 VT_AXIS = 4 6676 }; 6677 int32_t axis() const { 6678 return GetField<int32_t>(VT_AXIS, 0); 6679 } 6680 bool Verify(flatbuffers::Verifier &verifier) const { 6681 return VerifyTableStart(verifier) && 6682 VerifyField<int32_t>(verifier, VT_AXIS) && 6683 verifier.EndTable(); 6684 } 6685 OneHotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6686 void UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6687 static flatbuffers::Offset<OneHotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6688 }; 6689 6690 struct OneHotOptionsBuilder { 6691 flatbuffers::FlatBufferBuilder &fbb_; 6692 flatbuffers::uoffset_t start_; 6693 void add_axis(int32_t axis) { 6694 fbb_.AddElement<int32_t>(OneHotOptions::VT_AXIS, axis, 0); 6695 } 6696 explicit OneHotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6697 : fbb_(_fbb) { 6698 start_ = fbb_.StartTable(); 6699 } 6700 OneHotOptionsBuilder &operator=(const OneHotOptionsBuilder &); 6701 flatbuffers::Offset<OneHotOptions> Finish() { 6702 const auto end = fbb_.EndTable(start_); 6703 auto o = flatbuffers::Offset<OneHotOptions>(end); 6704 return o; 6705 } 6706 }; 6707 6708 inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions( 6709 flatbuffers::FlatBufferBuilder &_fbb, 6710 int32_t axis = 0) { 6711 OneHotOptionsBuilder builder_(_fbb); 6712 builder_.add_axis(axis); 6713 return builder_.Finish(); 6714 } 6715 6716 flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6717 6718 struct AbsOptionsT : public flatbuffers::NativeTable { 6719 typedef AbsOptions TableType; 6720 AbsOptionsT() { 6721 } 6722 }; 6723 6724 struct AbsOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6725 typedef AbsOptionsT NativeTableType; 6726 bool Verify(flatbuffers::Verifier &verifier) const { 6727 return VerifyTableStart(verifier) && 6728 verifier.EndTable(); 6729 } 6730 AbsOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6731 void UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6732 static flatbuffers::Offset<AbsOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6733 }; 6734 6735 struct AbsOptionsBuilder { 6736 flatbuffers::FlatBufferBuilder &fbb_; 6737 flatbuffers::uoffset_t start_; 6738 explicit AbsOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6739 : fbb_(_fbb) { 6740 start_ = fbb_.StartTable(); 6741 } 6742 AbsOptionsBuilder &operator=(const AbsOptionsBuilder &); 6743 flatbuffers::Offset<AbsOptions> Finish() { 6744 const auto end = fbb_.EndTable(start_); 6745 auto o = flatbuffers::Offset<AbsOptions>(end); 6746 return o; 6747 } 6748 }; 6749 6750 inline flatbuffers::Offset<AbsOptions> CreateAbsOptions( 6751 flatbuffers::FlatBufferBuilder &_fbb) { 6752 AbsOptionsBuilder builder_(_fbb); 6753 return builder_.Finish(); 6754 } 6755 6756 flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6757 6758 struct LogicalAndOptionsT : public flatbuffers::NativeTable { 6759 typedef LogicalAndOptions TableType; 6760 LogicalAndOptionsT() { 6761 } 6762 }; 6763 6764 struct LogicalAndOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6765 typedef LogicalAndOptionsT NativeTableType; 6766 bool Verify(flatbuffers::Verifier &verifier) const { 6767 return VerifyTableStart(verifier) && 6768 verifier.EndTable(); 6769 } 6770 LogicalAndOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6771 void UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6772 static flatbuffers::Offset<LogicalAndOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6773 }; 6774 6775 struct LogicalAndOptionsBuilder { 6776 flatbuffers::FlatBufferBuilder &fbb_; 6777 flatbuffers::uoffset_t start_; 6778 explicit LogicalAndOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6779 : fbb_(_fbb) { 6780 start_ = fbb_.StartTable(); 6781 } 6782 LogicalAndOptionsBuilder &operator=(const LogicalAndOptionsBuilder &); 6783 flatbuffers::Offset<LogicalAndOptions> Finish() { 6784 const auto end = fbb_.EndTable(start_); 6785 auto o = flatbuffers::Offset<LogicalAndOptions>(end); 6786 return o; 6787 } 6788 }; 6789 6790 inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions( 6791 flatbuffers::FlatBufferBuilder &_fbb) { 6792 LogicalAndOptionsBuilder builder_(_fbb); 6793 return builder_.Finish(); 6794 } 6795 6796 flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6797 6798 struct LogicalNotOptionsT : public flatbuffers::NativeTable { 6799 typedef LogicalNotOptions TableType; 6800 LogicalNotOptionsT() { 6801 } 6802 }; 6803 6804 struct LogicalNotOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6805 typedef LogicalNotOptionsT NativeTableType; 6806 bool Verify(flatbuffers::Verifier &verifier) const { 6807 return VerifyTableStart(verifier) && 6808 verifier.EndTable(); 6809 } 6810 LogicalNotOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6811 void UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6812 static flatbuffers::Offset<LogicalNotOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6813 }; 6814 6815 struct LogicalNotOptionsBuilder { 6816 flatbuffers::FlatBufferBuilder &fbb_; 6817 flatbuffers::uoffset_t start_; 6818 explicit LogicalNotOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6819 : fbb_(_fbb) { 6820 start_ = fbb_.StartTable(); 6821 } 6822 LogicalNotOptionsBuilder &operator=(const LogicalNotOptionsBuilder &); 6823 flatbuffers::Offset<LogicalNotOptions> Finish() { 6824 const auto end = fbb_.EndTable(start_); 6825 auto o = flatbuffers::Offset<LogicalNotOptions>(end); 6826 return o; 6827 } 6828 }; 6829 6830 inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions( 6831 flatbuffers::FlatBufferBuilder &_fbb) { 6832 LogicalNotOptionsBuilder builder_(_fbb); 6833 return builder_.Finish(); 6834 } 6835 6836 flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6837 6838 struct UnpackOptionsT : public flatbuffers::NativeTable { 6839 typedef UnpackOptions TableType; 6840 int32_t num; 6841 int32_t axis; 6842 UnpackOptionsT() 6843 : num(0), 6844 axis(0) { 6845 } 6846 }; 6847 6848 struct UnpackOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6849 typedef UnpackOptionsT NativeTableType; 6850 enum { 6851 VT_NUM = 4, 6852 VT_AXIS = 6 6853 }; 6854 int32_t num() const { 6855 return GetField<int32_t>(VT_NUM, 0); 6856 } 6857 int32_t axis() const { 6858 return GetField<int32_t>(VT_AXIS, 0); 6859 } 6860 bool Verify(flatbuffers::Verifier &verifier) const { 6861 return VerifyTableStart(verifier) && 6862 VerifyField<int32_t>(verifier, VT_NUM) && 6863 VerifyField<int32_t>(verifier, VT_AXIS) && 6864 verifier.EndTable(); 6865 } 6866 UnpackOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6867 void UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6868 static flatbuffers::Offset<UnpackOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6869 }; 6870 6871 struct UnpackOptionsBuilder { 6872 flatbuffers::FlatBufferBuilder &fbb_; 6873 flatbuffers::uoffset_t start_; 6874 void add_num(int32_t num) { 6875 fbb_.AddElement<int32_t>(UnpackOptions::VT_NUM, num, 0); 6876 } 6877 void add_axis(int32_t axis) { 6878 fbb_.AddElement<int32_t>(UnpackOptions::VT_AXIS, axis, 0); 6879 } 6880 explicit UnpackOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6881 : fbb_(_fbb) { 6882 start_ = fbb_.StartTable(); 6883 } 6884 UnpackOptionsBuilder &operator=(const UnpackOptionsBuilder &); 6885 flatbuffers::Offset<UnpackOptions> Finish() { 6886 const auto end = fbb_.EndTable(start_); 6887 auto o = flatbuffers::Offset<UnpackOptions>(end); 6888 return o; 6889 } 6890 }; 6891 6892 inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions( 6893 flatbuffers::FlatBufferBuilder &_fbb, 6894 int32_t num = 0, 6895 int32_t axis = 0) { 6896 UnpackOptionsBuilder builder_(_fbb); 6897 builder_.add_axis(axis); 6898 builder_.add_num(num); 6899 return builder_.Finish(); 6900 } 6901 6902 flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6903 6904 struct FloorDivOptionsT : public flatbuffers::NativeTable { 6905 typedef FloorDivOptions TableType; 6906 FloorDivOptionsT() { 6907 } 6908 }; 6909 6910 struct FloorDivOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6911 typedef FloorDivOptionsT NativeTableType; 6912 bool Verify(flatbuffers::Verifier &verifier) const { 6913 return VerifyTableStart(verifier) && 6914 verifier.EndTable(); 6915 } 6916 FloorDivOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6917 void UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6918 static flatbuffers::Offset<FloorDivOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6919 }; 6920 6921 struct FloorDivOptionsBuilder { 6922 flatbuffers::FlatBufferBuilder &fbb_; 6923 flatbuffers::uoffset_t start_; 6924 explicit FloorDivOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6925 : fbb_(_fbb) { 6926 start_ = fbb_.StartTable(); 6927 } 6928 FloorDivOptionsBuilder &operator=(const FloorDivOptionsBuilder &); 6929 flatbuffers::Offset<FloorDivOptions> Finish() { 6930 const auto end = fbb_.EndTable(start_); 6931 auto o = flatbuffers::Offset<FloorDivOptions>(end); 6932 return o; 6933 } 6934 }; 6935 6936 inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions( 6937 flatbuffers::FlatBufferBuilder &_fbb) { 6938 FloorDivOptionsBuilder builder_(_fbb); 6939 return builder_.Finish(); 6940 } 6941 6942 flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6943 6944 struct SquareOptionsT : public flatbuffers::NativeTable { 6945 typedef SquareOptions TableType; 6946 SquareOptionsT() { 6947 } 6948 }; 6949 6950 struct SquareOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6951 typedef SquareOptionsT NativeTableType; 6952 bool Verify(flatbuffers::Verifier &verifier) const { 6953 return VerifyTableStart(verifier) && 6954 verifier.EndTable(); 6955 } 6956 SquareOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6957 void UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6958 static flatbuffers::Offset<SquareOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6959 }; 6960 6961 struct SquareOptionsBuilder { 6962 flatbuffers::FlatBufferBuilder &fbb_; 6963 flatbuffers::uoffset_t start_; 6964 explicit SquareOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 6965 : fbb_(_fbb) { 6966 start_ = fbb_.StartTable(); 6967 } 6968 SquareOptionsBuilder &operator=(const SquareOptionsBuilder &); 6969 flatbuffers::Offset<SquareOptions> Finish() { 6970 const auto end = fbb_.EndTable(start_); 6971 auto o = flatbuffers::Offset<SquareOptions>(end); 6972 return o; 6973 } 6974 }; 6975 6976 inline flatbuffers::Offset<SquareOptions> CreateSquareOptions( 6977 flatbuffers::FlatBufferBuilder &_fbb) { 6978 SquareOptionsBuilder builder_(_fbb); 6979 return builder_.Finish(); 6980 } 6981 6982 flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6983 6984 struct ZerosLikeOptionsT : public flatbuffers::NativeTable { 6985 typedef ZerosLikeOptions TableType; 6986 ZerosLikeOptionsT() { 6987 } 6988 }; 6989 6990 struct ZerosLikeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 6991 typedef ZerosLikeOptionsT NativeTableType; 6992 bool Verify(flatbuffers::Verifier &verifier) const { 6993 return VerifyTableStart(verifier) && 6994 verifier.EndTable(); 6995 } 6996 ZerosLikeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6997 void UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 6998 static flatbuffers::Offset<ZerosLikeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 6999 }; 7000 7001 struct ZerosLikeOptionsBuilder { 7002 flatbuffers::FlatBufferBuilder &fbb_; 7003 flatbuffers::uoffset_t start_; 7004 explicit ZerosLikeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7005 : fbb_(_fbb) { 7006 start_ = fbb_.StartTable(); 7007 } 7008 ZerosLikeOptionsBuilder &operator=(const ZerosLikeOptionsBuilder &); 7009 flatbuffers::Offset<ZerosLikeOptions> Finish() { 7010 const auto end = fbb_.EndTable(start_); 7011 auto o = flatbuffers::Offset<ZerosLikeOptions>(end); 7012 return o; 7013 } 7014 }; 7015 7016 inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions( 7017 flatbuffers::FlatBufferBuilder &_fbb) { 7018 ZerosLikeOptionsBuilder builder_(_fbb); 7019 return builder_.Finish(); 7020 } 7021 7022 flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7023 7024 struct FillOptionsT : public flatbuffers::NativeTable { 7025 typedef FillOptions TableType; 7026 FillOptionsT() { 7027 } 7028 }; 7029 7030 struct FillOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7031 typedef FillOptionsT NativeTableType; 7032 bool Verify(flatbuffers::Verifier &verifier) const { 7033 return VerifyTableStart(verifier) && 7034 verifier.EndTable(); 7035 } 7036 FillOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7037 void UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7038 static flatbuffers::Offset<FillOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7039 }; 7040 7041 struct FillOptionsBuilder { 7042 flatbuffers::FlatBufferBuilder &fbb_; 7043 flatbuffers::uoffset_t start_; 7044 explicit FillOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7045 : fbb_(_fbb) { 7046 start_ = fbb_.StartTable(); 7047 } 7048 FillOptionsBuilder &operator=(const FillOptionsBuilder &); 7049 flatbuffers::Offset<FillOptions> Finish() { 7050 const auto end = fbb_.EndTable(start_); 7051 auto o = flatbuffers::Offset<FillOptions>(end); 7052 return o; 7053 } 7054 }; 7055 7056 inline flatbuffers::Offset<FillOptions> CreateFillOptions( 7057 flatbuffers::FlatBufferBuilder &_fbb) { 7058 FillOptionsBuilder builder_(_fbb); 7059 return builder_.Finish(); 7060 } 7061 7062 flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7063 7064 struct FloorModOptionsT : public flatbuffers::NativeTable { 7065 typedef FloorModOptions TableType; 7066 FloorModOptionsT() { 7067 } 7068 }; 7069 7070 struct FloorModOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7071 typedef FloorModOptionsT NativeTableType; 7072 bool Verify(flatbuffers::Verifier &verifier) const { 7073 return VerifyTableStart(verifier) && 7074 verifier.EndTable(); 7075 } 7076 FloorModOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7077 void UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7078 static flatbuffers::Offset<FloorModOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7079 }; 7080 7081 struct FloorModOptionsBuilder { 7082 flatbuffers::FlatBufferBuilder &fbb_; 7083 flatbuffers::uoffset_t start_; 7084 explicit FloorModOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7085 : fbb_(_fbb) { 7086 start_ = fbb_.StartTable(); 7087 } 7088 FloorModOptionsBuilder &operator=(const FloorModOptionsBuilder &); 7089 flatbuffers::Offset<FloorModOptions> Finish() { 7090 const auto end = fbb_.EndTable(start_); 7091 auto o = flatbuffers::Offset<FloorModOptions>(end); 7092 return o; 7093 } 7094 }; 7095 7096 inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions( 7097 flatbuffers::FlatBufferBuilder &_fbb) { 7098 FloorModOptionsBuilder builder_(_fbb); 7099 return builder_.Finish(); 7100 } 7101 7102 flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7103 7104 struct RangeOptionsT : public flatbuffers::NativeTable { 7105 typedef RangeOptions TableType; 7106 RangeOptionsT() { 7107 } 7108 }; 7109 7110 struct RangeOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7111 typedef RangeOptionsT NativeTableType; 7112 bool Verify(flatbuffers::Verifier &verifier) const { 7113 return VerifyTableStart(verifier) && 7114 verifier.EndTable(); 7115 } 7116 RangeOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7117 void UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7118 static flatbuffers::Offset<RangeOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7119 }; 7120 7121 struct RangeOptionsBuilder { 7122 flatbuffers::FlatBufferBuilder &fbb_; 7123 flatbuffers::uoffset_t start_; 7124 explicit RangeOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7125 : fbb_(_fbb) { 7126 start_ = fbb_.StartTable(); 7127 } 7128 RangeOptionsBuilder &operator=(const RangeOptionsBuilder &); 7129 flatbuffers::Offset<RangeOptions> Finish() { 7130 const auto end = fbb_.EndTable(start_); 7131 auto o = flatbuffers::Offset<RangeOptions>(end); 7132 return o; 7133 } 7134 }; 7135 7136 inline flatbuffers::Offset<RangeOptions> CreateRangeOptions( 7137 flatbuffers::FlatBufferBuilder &_fbb) { 7138 RangeOptionsBuilder builder_(_fbb); 7139 return builder_.Finish(); 7140 } 7141 7142 flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7143 7144 struct LeakyReluOptionsT : public flatbuffers::NativeTable { 7145 typedef LeakyReluOptions TableType; 7146 float alpha; 7147 LeakyReluOptionsT() 7148 : alpha(0.0f) { 7149 } 7150 }; 7151 7152 struct LeakyReluOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7153 typedef LeakyReluOptionsT NativeTableType; 7154 enum { 7155 VT_ALPHA = 4 7156 }; 7157 float alpha() const { 7158 return GetField<float>(VT_ALPHA, 0.0f); 7159 } 7160 bool Verify(flatbuffers::Verifier &verifier) const { 7161 return VerifyTableStart(verifier) && 7162 VerifyField<float>(verifier, VT_ALPHA) && 7163 verifier.EndTable(); 7164 } 7165 LeakyReluOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7166 void UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7167 static flatbuffers::Offset<LeakyReluOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7168 }; 7169 7170 struct LeakyReluOptionsBuilder { 7171 flatbuffers::FlatBufferBuilder &fbb_; 7172 flatbuffers::uoffset_t start_; 7173 void add_alpha(float alpha) { 7174 fbb_.AddElement<float>(LeakyReluOptions::VT_ALPHA, alpha, 0.0f); 7175 } 7176 explicit LeakyReluOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7177 : fbb_(_fbb) { 7178 start_ = fbb_.StartTable(); 7179 } 7180 LeakyReluOptionsBuilder &operator=(const LeakyReluOptionsBuilder &); 7181 flatbuffers::Offset<LeakyReluOptions> Finish() { 7182 const auto end = fbb_.EndTable(start_); 7183 auto o = flatbuffers::Offset<LeakyReluOptions>(end); 7184 return o; 7185 } 7186 }; 7187 7188 inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions( 7189 flatbuffers::FlatBufferBuilder &_fbb, 7190 float alpha = 0.0f) { 7191 LeakyReluOptionsBuilder builder_(_fbb); 7192 builder_.add_alpha(alpha); 7193 return builder_.Finish(); 7194 } 7195 7196 flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7197 7198 struct SquaredDifferenceOptionsT : public flatbuffers::NativeTable { 7199 typedef SquaredDifferenceOptions TableType; 7200 SquaredDifferenceOptionsT() { 7201 } 7202 }; 7203 7204 struct SquaredDifferenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7205 typedef SquaredDifferenceOptionsT NativeTableType; 7206 bool Verify(flatbuffers::Verifier &verifier) const { 7207 return VerifyTableStart(verifier) && 7208 verifier.EndTable(); 7209 } 7210 SquaredDifferenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7211 void UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7212 static flatbuffers::Offset<SquaredDifferenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7213 }; 7214 7215 struct SquaredDifferenceOptionsBuilder { 7216 flatbuffers::FlatBufferBuilder &fbb_; 7217 flatbuffers::uoffset_t start_; 7218 explicit SquaredDifferenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7219 : fbb_(_fbb) { 7220 start_ = fbb_.StartTable(); 7221 } 7222 SquaredDifferenceOptionsBuilder &operator=(const SquaredDifferenceOptionsBuilder &); 7223 flatbuffers::Offset<SquaredDifferenceOptions> Finish() { 7224 const auto end = fbb_.EndTable(start_); 7225 auto o = flatbuffers::Offset<SquaredDifferenceOptions>(end); 7226 return o; 7227 } 7228 }; 7229 7230 inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions( 7231 flatbuffers::FlatBufferBuilder &_fbb) { 7232 SquaredDifferenceOptionsBuilder builder_(_fbb); 7233 return builder_.Finish(); 7234 } 7235 7236 flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7237 7238 struct MirrorPadOptionsT : public flatbuffers::NativeTable { 7239 typedef MirrorPadOptions TableType; 7240 MirrorPadMode mode; 7241 MirrorPadOptionsT() 7242 : mode(MirrorPadMode_REFLECT) { 7243 } 7244 }; 7245 7246 struct MirrorPadOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7247 typedef MirrorPadOptionsT NativeTableType; 7248 enum { 7249 VT_MODE = 4 7250 }; 7251 MirrorPadMode mode() const { 7252 return static_cast<MirrorPadMode>(GetField<int8_t>(VT_MODE, 0)); 7253 } 7254 bool Verify(flatbuffers::Verifier &verifier) const { 7255 return VerifyTableStart(verifier) && 7256 VerifyField<int8_t>(verifier, VT_MODE) && 7257 verifier.EndTable(); 7258 } 7259 MirrorPadOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7260 void UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7261 static flatbuffers::Offset<MirrorPadOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7262 }; 7263 7264 struct MirrorPadOptionsBuilder { 7265 flatbuffers::FlatBufferBuilder &fbb_; 7266 flatbuffers::uoffset_t start_; 7267 void add_mode(MirrorPadMode mode) { 7268 fbb_.AddElement<int8_t>(MirrorPadOptions::VT_MODE, static_cast<int8_t>(mode), 0); 7269 } 7270 explicit MirrorPadOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7271 : fbb_(_fbb) { 7272 start_ = fbb_.StartTable(); 7273 } 7274 MirrorPadOptionsBuilder &operator=(const MirrorPadOptionsBuilder &); 7275 flatbuffers::Offset<MirrorPadOptions> Finish() { 7276 const auto end = fbb_.EndTable(start_); 7277 auto o = flatbuffers::Offset<MirrorPadOptions>(end); 7278 return o; 7279 } 7280 }; 7281 7282 inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions( 7283 flatbuffers::FlatBufferBuilder &_fbb, 7284 MirrorPadMode mode = MirrorPadMode_REFLECT) { 7285 MirrorPadOptionsBuilder builder_(_fbb); 7286 builder_.add_mode(mode); 7287 return builder_.Finish(); 7288 } 7289 7290 flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7291 7292 struct UniqueOptionsT : public flatbuffers::NativeTable { 7293 typedef UniqueOptions TableType; 7294 TensorType idx_out_type; 7295 UniqueOptionsT() 7296 : idx_out_type(TensorType_INT32) { 7297 } 7298 }; 7299 7300 struct UniqueOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7301 typedef UniqueOptionsT NativeTableType; 7302 enum { 7303 VT_IDX_OUT_TYPE = 4 7304 }; 7305 TensorType idx_out_type() const { 7306 return static_cast<TensorType>(GetField<int8_t>(VT_IDX_OUT_TYPE, 2)); 7307 } 7308 bool Verify(flatbuffers::Verifier &verifier) const { 7309 return VerifyTableStart(verifier) && 7310 VerifyField<int8_t>(verifier, VT_IDX_OUT_TYPE) && 7311 verifier.EndTable(); 7312 } 7313 UniqueOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7314 void UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7315 static flatbuffers::Offset<UniqueOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7316 }; 7317 7318 struct UniqueOptionsBuilder { 7319 flatbuffers::FlatBufferBuilder &fbb_; 7320 flatbuffers::uoffset_t start_; 7321 void add_idx_out_type(TensorType idx_out_type) { 7322 fbb_.AddElement<int8_t>(UniqueOptions::VT_IDX_OUT_TYPE, static_cast<int8_t>(idx_out_type), 2); 7323 } 7324 explicit UniqueOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7325 : fbb_(_fbb) { 7326 start_ = fbb_.StartTable(); 7327 } 7328 UniqueOptionsBuilder &operator=(const UniqueOptionsBuilder &); 7329 flatbuffers::Offset<UniqueOptions> Finish() { 7330 const auto end = fbb_.EndTable(start_); 7331 auto o = flatbuffers::Offset<UniqueOptions>(end); 7332 return o; 7333 } 7334 }; 7335 7336 inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions( 7337 flatbuffers::FlatBufferBuilder &_fbb, 7338 TensorType idx_out_type = TensorType_INT32) { 7339 UniqueOptionsBuilder builder_(_fbb); 7340 builder_.add_idx_out_type(idx_out_type); 7341 return builder_.Finish(); 7342 } 7343 7344 flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7345 7346 struct ReverseV2OptionsT : public flatbuffers::NativeTable { 7347 typedef ReverseV2Options TableType; 7348 ReverseV2OptionsT() { 7349 } 7350 }; 7351 7352 struct ReverseV2Options FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7353 typedef ReverseV2OptionsT NativeTableType; 7354 bool Verify(flatbuffers::Verifier &verifier) const { 7355 return VerifyTableStart(verifier) && 7356 verifier.EndTable(); 7357 } 7358 ReverseV2OptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7359 void UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7360 static flatbuffers::Offset<ReverseV2Options> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7361 }; 7362 7363 struct ReverseV2OptionsBuilder { 7364 flatbuffers::FlatBufferBuilder &fbb_; 7365 flatbuffers::uoffset_t start_; 7366 explicit ReverseV2OptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7367 : fbb_(_fbb) { 7368 start_ = fbb_.StartTable(); 7369 } 7370 ReverseV2OptionsBuilder &operator=(const ReverseV2OptionsBuilder &); 7371 flatbuffers::Offset<ReverseV2Options> Finish() { 7372 const auto end = fbb_.EndTable(start_); 7373 auto o = flatbuffers::Offset<ReverseV2Options>(end); 7374 return o; 7375 } 7376 }; 7377 7378 inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options( 7379 flatbuffers::FlatBufferBuilder &_fbb) { 7380 ReverseV2OptionsBuilder builder_(_fbb); 7381 return builder_.Finish(); 7382 } 7383 7384 flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7385 7386 struct AddNOptionsT : public flatbuffers::NativeTable { 7387 typedef AddNOptions TableType; 7388 AddNOptionsT() { 7389 } 7390 }; 7391 7392 struct AddNOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7393 typedef AddNOptionsT NativeTableType; 7394 bool Verify(flatbuffers::Verifier &verifier) const { 7395 return VerifyTableStart(verifier) && 7396 verifier.EndTable(); 7397 } 7398 AddNOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7399 void UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7400 static flatbuffers::Offset<AddNOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7401 }; 7402 7403 struct AddNOptionsBuilder { 7404 flatbuffers::FlatBufferBuilder &fbb_; 7405 flatbuffers::uoffset_t start_; 7406 explicit AddNOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7407 : fbb_(_fbb) { 7408 start_ = fbb_.StartTable(); 7409 } 7410 AddNOptionsBuilder &operator=(const AddNOptionsBuilder &); 7411 flatbuffers::Offset<AddNOptions> Finish() { 7412 const auto end = fbb_.EndTable(start_); 7413 auto o = flatbuffers::Offset<AddNOptions>(end); 7414 return o; 7415 } 7416 }; 7417 7418 inline flatbuffers::Offset<AddNOptions> CreateAddNOptions( 7419 flatbuffers::FlatBufferBuilder &_fbb) { 7420 AddNOptionsBuilder builder_(_fbb); 7421 return builder_.Finish(); 7422 } 7423 7424 flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7425 7426 struct GatherNdOptionsT : public flatbuffers::NativeTable { 7427 typedef GatherNdOptions TableType; 7428 GatherNdOptionsT() { 7429 } 7430 }; 7431 7432 struct GatherNdOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7433 typedef GatherNdOptionsT NativeTableType; 7434 bool Verify(flatbuffers::Verifier &verifier) const { 7435 return VerifyTableStart(verifier) && 7436 verifier.EndTable(); 7437 } 7438 GatherNdOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7439 void UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7440 static flatbuffers::Offset<GatherNdOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7441 }; 7442 7443 struct GatherNdOptionsBuilder { 7444 flatbuffers::FlatBufferBuilder &fbb_; 7445 flatbuffers::uoffset_t start_; 7446 explicit GatherNdOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7447 : fbb_(_fbb) { 7448 start_ = fbb_.StartTable(); 7449 } 7450 GatherNdOptionsBuilder &operator=(const GatherNdOptionsBuilder &); 7451 flatbuffers::Offset<GatherNdOptions> Finish() { 7452 const auto end = fbb_.EndTable(start_); 7453 auto o = flatbuffers::Offset<GatherNdOptions>(end); 7454 return o; 7455 } 7456 }; 7457 7458 inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions( 7459 flatbuffers::FlatBufferBuilder &_fbb) { 7460 GatherNdOptionsBuilder builder_(_fbb); 7461 return builder_.Finish(); 7462 } 7463 7464 flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7465 7466 struct WhereOptionsT : public flatbuffers::NativeTable { 7467 typedef WhereOptions TableType; 7468 WhereOptionsT() { 7469 } 7470 }; 7471 7472 struct WhereOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7473 typedef WhereOptionsT NativeTableType; 7474 bool Verify(flatbuffers::Verifier &verifier) const { 7475 return VerifyTableStart(verifier) && 7476 verifier.EndTable(); 7477 } 7478 WhereOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7479 void UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7480 static flatbuffers::Offset<WhereOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7481 }; 7482 7483 struct WhereOptionsBuilder { 7484 flatbuffers::FlatBufferBuilder &fbb_; 7485 flatbuffers::uoffset_t start_; 7486 explicit WhereOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7487 : fbb_(_fbb) { 7488 start_ = fbb_.StartTable(); 7489 } 7490 WhereOptionsBuilder &operator=(const WhereOptionsBuilder &); 7491 flatbuffers::Offset<WhereOptions> Finish() { 7492 const auto end = fbb_.EndTable(start_); 7493 auto o = flatbuffers::Offset<WhereOptions>(end); 7494 return o; 7495 } 7496 }; 7497 7498 inline flatbuffers::Offset<WhereOptions> CreateWhereOptions( 7499 flatbuffers::FlatBufferBuilder &_fbb) { 7500 WhereOptionsBuilder builder_(_fbb); 7501 return builder_.Finish(); 7502 } 7503 7504 flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7505 7506 struct ReverseSequenceOptionsT : public flatbuffers::NativeTable { 7507 typedef ReverseSequenceOptions TableType; 7508 int32_t seq_dim; 7509 int32_t batch_dim; 7510 ReverseSequenceOptionsT() 7511 : seq_dim(0), 7512 batch_dim(0) { 7513 } 7514 }; 7515 7516 struct ReverseSequenceOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7517 typedef ReverseSequenceOptionsT NativeTableType; 7518 enum { 7519 VT_SEQ_DIM = 4, 7520 VT_BATCH_DIM = 6 7521 }; 7522 int32_t seq_dim() const { 7523 return GetField<int32_t>(VT_SEQ_DIM, 0); 7524 } 7525 int32_t batch_dim() const { 7526 return GetField<int32_t>(VT_BATCH_DIM, 0); 7527 } 7528 bool Verify(flatbuffers::Verifier &verifier) const { 7529 return VerifyTableStart(verifier) && 7530 VerifyField<int32_t>(verifier, VT_SEQ_DIM) && 7531 VerifyField<int32_t>(verifier, VT_BATCH_DIM) && 7532 verifier.EndTable(); 7533 } 7534 ReverseSequenceOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7535 void UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7536 static flatbuffers::Offset<ReverseSequenceOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7537 }; 7538 7539 struct ReverseSequenceOptionsBuilder { 7540 flatbuffers::FlatBufferBuilder &fbb_; 7541 flatbuffers::uoffset_t start_; 7542 void add_seq_dim(int32_t seq_dim) { 7543 fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_SEQ_DIM, seq_dim, 0); 7544 } 7545 void add_batch_dim(int32_t batch_dim) { 7546 fbb_.AddElement<int32_t>(ReverseSequenceOptions::VT_BATCH_DIM, batch_dim, 0); 7547 } 7548 explicit ReverseSequenceOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7549 : fbb_(_fbb) { 7550 start_ = fbb_.StartTable(); 7551 } 7552 ReverseSequenceOptionsBuilder &operator=(const ReverseSequenceOptionsBuilder &); 7553 flatbuffers::Offset<ReverseSequenceOptions> Finish() { 7554 const auto end = fbb_.EndTable(start_); 7555 auto o = flatbuffers::Offset<ReverseSequenceOptions>(end); 7556 return o; 7557 } 7558 }; 7559 7560 inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions( 7561 flatbuffers::FlatBufferBuilder &_fbb, 7562 int32_t seq_dim = 0, 7563 int32_t batch_dim = 0) { 7564 ReverseSequenceOptionsBuilder builder_(_fbb); 7565 builder_.add_batch_dim(batch_dim); 7566 builder_.add_seq_dim(seq_dim); 7567 return builder_.Finish(); 7568 } 7569 7570 flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7571 7572 struct OperatorCodeT : public flatbuffers::NativeTable { 7573 typedef OperatorCode TableType; 7574 BuiltinOperator builtin_code; 7575 std::string custom_code; 7576 int32_t version; 7577 OperatorCodeT() 7578 : builtin_code(BuiltinOperator_ADD), 7579 version(1) { 7580 } 7581 }; 7582 7583 struct OperatorCode FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7584 typedef OperatorCodeT NativeTableType; 7585 enum { 7586 VT_BUILTIN_CODE = 4, 7587 VT_CUSTOM_CODE = 6, 7588 VT_VERSION = 8 7589 }; 7590 BuiltinOperator builtin_code() const { 7591 return static_cast<BuiltinOperator>(GetField<int8_t>(VT_BUILTIN_CODE, 0)); 7592 } 7593 const flatbuffers::String *custom_code() const { 7594 return GetPointer<const flatbuffers::String *>(VT_CUSTOM_CODE); 7595 } 7596 int32_t version() const { 7597 return GetField<int32_t>(VT_VERSION, 1); 7598 } 7599 bool Verify(flatbuffers::Verifier &verifier) const { 7600 return VerifyTableStart(verifier) && 7601 VerifyField<int8_t>(verifier, VT_BUILTIN_CODE) && 7602 VerifyOffset(verifier, VT_CUSTOM_CODE) && 7603 verifier.VerifyString(custom_code()) && 7604 VerifyField<int32_t>(verifier, VT_VERSION) && 7605 verifier.EndTable(); 7606 } 7607 OperatorCodeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7608 void UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7609 static flatbuffers::Offset<OperatorCode> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7610 }; 7611 7612 struct OperatorCodeBuilder { 7613 flatbuffers::FlatBufferBuilder &fbb_; 7614 flatbuffers::uoffset_t start_; 7615 void add_builtin_code(BuiltinOperator builtin_code) { 7616 fbb_.AddElement<int8_t>(OperatorCode::VT_BUILTIN_CODE, static_cast<int8_t>(builtin_code), 0); 7617 } 7618 void add_custom_code(flatbuffers::Offset<flatbuffers::String> custom_code) { 7619 fbb_.AddOffset(OperatorCode::VT_CUSTOM_CODE, custom_code); 7620 } 7621 void add_version(int32_t version) { 7622 fbb_.AddElement<int32_t>(OperatorCode::VT_VERSION, version, 1); 7623 } 7624 explicit OperatorCodeBuilder(flatbuffers::FlatBufferBuilder &_fbb) 7625 : fbb_(_fbb) { 7626 start_ = fbb_.StartTable(); 7627 } 7628 OperatorCodeBuilder &operator=(const OperatorCodeBuilder &); 7629 flatbuffers::Offset<OperatorCode> Finish() { 7630 const auto end = fbb_.EndTable(start_); 7631 auto o = flatbuffers::Offset<OperatorCode>(end); 7632 return o; 7633 } 7634 }; 7635 7636 inline flatbuffers::Offset<OperatorCode> CreateOperatorCode( 7637 flatbuffers::FlatBufferBuilder &_fbb, 7638 BuiltinOperator builtin_code = BuiltinOperator_ADD, 7639 flatbuffers::Offset<flatbuffers::String> custom_code = 0, 7640 int32_t version = 1) { 7641 OperatorCodeBuilder builder_(_fbb); 7642 builder_.add_version(version); 7643 builder_.add_custom_code(custom_code); 7644 builder_.add_builtin_code(builtin_code); 7645 return builder_.Finish(); 7646 } 7647 7648 inline flatbuffers::Offset<OperatorCode> CreateOperatorCodeDirect( 7649 flatbuffers::FlatBufferBuilder &_fbb, 7650 BuiltinOperator builtin_code = BuiltinOperator_ADD, 7651 const char *custom_code = nullptr, 7652 int32_t version = 1) { 7653 return tflite::CreateOperatorCode( 7654 _fbb, 7655 builtin_code, 7656 custom_code ? _fbb.CreateString(custom_code) : 0, 7657 version); 7658 } 7659 7660 flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7661 7662 struct OperatorT : public flatbuffers::NativeTable { 7663 typedef Operator TableType; 7664 uint32_t opcode_index; 7665 std::vector<int32_t> inputs; 7666 std::vector<int32_t> outputs; 7667 BuiltinOptionsUnion builtin_options; 7668 std::vector<uint8_t> custom_options; 7669 CustomOptionsFormat custom_options_format; 7670 std::vector<bool> mutating_variable_inputs; 7671 OperatorT() 7672 : opcode_index(0), 7673 custom_options_format(CustomOptionsFormat_FLEXBUFFERS) { 7674 } 7675 }; 7676 7677 struct Operator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 7678 typedef OperatorT NativeTableType; 7679 enum { 7680 VT_OPCODE_INDEX = 4, 7681 VT_INPUTS = 6, 7682 VT_OUTPUTS = 8, 7683 VT_BUILTIN_OPTIONS_TYPE = 10, 7684 VT_BUILTIN_OPTIONS = 12, 7685 VT_CUSTOM_OPTIONS = 14, 7686 VT_CUSTOM_OPTIONS_FORMAT = 16, 7687 VT_MUTATING_VARIABLE_INPUTS = 18 7688 }; 7689 uint32_t opcode_index() const { 7690 return GetField<uint32_t>(VT_OPCODE_INDEX, 0); 7691 } 7692 const flatbuffers::Vector<int32_t> *inputs() const { 7693 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS); 7694 } 7695 const flatbuffers::Vector<int32_t> *outputs() const { 7696 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS); 7697 } 7698 BuiltinOptions builtin_options_type() const { 7699 return static_cast<BuiltinOptions>(GetField<uint8_t>(VT_BUILTIN_OPTIONS_TYPE, 0)); 7700 } 7701 const void *builtin_options() const { 7702 return GetPointer<const void *>(VT_BUILTIN_OPTIONS); 7703 } 7704 template<typename T> const T *builtin_options_as() const; 7705 const Conv2DOptions *builtin_options_as_Conv2DOptions() const { 7706 return builtin_options_type() == BuiltinOptions_Conv2DOptions ? static_cast<const Conv2DOptions *>(builtin_options()) : nullptr; 7707 } 7708 const DepthwiseConv2DOptions *builtin_options_as_DepthwiseConv2DOptions() const { 7709 return builtin_options_type() == BuiltinOptions_DepthwiseConv2DOptions ? static_cast<const DepthwiseConv2DOptions *>(builtin_options()) : nullptr; 7710 } 7711 const ConcatEmbeddingsOptions *builtin_options_as_ConcatEmbeddingsOptions() const { 7712 return builtin_options_type() == BuiltinOptions_ConcatEmbeddingsOptions ? static_cast<const ConcatEmbeddingsOptions *>(builtin_options()) : nullptr; 7713 } 7714 const LSHProjectionOptions *builtin_options_as_LSHProjectionOptions() const { 7715 return builtin_options_type() == BuiltinOptions_LSHProjectionOptions ? static_cast<const LSHProjectionOptions *>(builtin_options()) : nullptr; 7716 } 7717 const Pool2DOptions *builtin_options_as_Pool2DOptions() const { 7718 return builtin_options_type() == BuiltinOptions_Pool2DOptions ? static_cast<const Pool2DOptions *>(builtin_options()) : nullptr; 7719 } 7720 const SVDFOptions *builtin_options_as_SVDFOptions() const { 7721 return builtin_options_type() == BuiltinOptions_SVDFOptions ? static_cast<const SVDFOptions *>(builtin_options()) : nullptr; 7722 } 7723 const RNNOptions *builtin_options_as_RNNOptions() const { 7724 return builtin_options_type() == BuiltinOptions_RNNOptions ? static_cast<const RNNOptions *>(builtin_options()) : nullptr; 7725 } 7726 const FullyConnectedOptions *builtin_options_as_FullyConnectedOptions() const { 7727 return builtin_options_type() == BuiltinOptions_FullyConnectedOptions ? static_cast<const FullyConnectedOptions *>(builtin_options()) : nullptr; 7728 } 7729 const SoftmaxOptions *builtin_options_as_SoftmaxOptions() const { 7730 return builtin_options_type() == BuiltinOptions_SoftmaxOptions ? static_cast<const SoftmaxOptions *>(builtin_options()) : nullptr; 7731 } 7732 const ConcatenationOptions *builtin_options_as_ConcatenationOptions() const { 7733 return builtin_options_type() == BuiltinOptions_ConcatenationOptions ? static_cast<const ConcatenationOptions *>(builtin_options()) : nullptr; 7734 } 7735 const AddOptions *builtin_options_as_AddOptions() const { 7736 return builtin_options_type() == BuiltinOptions_AddOptions ? static_cast<const AddOptions *>(builtin_options()) : nullptr; 7737 } 7738 const L2NormOptions *builtin_options_as_L2NormOptions() const { 7739 return builtin_options_type() == BuiltinOptions_L2NormOptions ? static_cast<const L2NormOptions *>(builtin_options()) : nullptr; 7740 } 7741 const LocalResponseNormalizationOptions *builtin_options_as_LocalResponseNormalizationOptions() const { 7742 return builtin_options_type() == BuiltinOptions_LocalResponseNormalizationOptions ? static_cast<const LocalResponseNormalizationOptions *>(builtin_options()) : nullptr; 7743 } 7744 const LSTMOptions *builtin_options_as_LSTMOptions() const { 7745 return builtin_options_type() == BuiltinOptions_LSTMOptions ? static_cast<const LSTMOptions *>(builtin_options()) : nullptr; 7746 } 7747 const ResizeBilinearOptions *builtin_options_as_ResizeBilinearOptions() const { 7748 return builtin_options_type() == BuiltinOptions_ResizeBilinearOptions ? static_cast<const ResizeBilinearOptions *>(builtin_options()) : nullptr; 7749 } 7750 const CallOptions *builtin_options_as_CallOptions() const { 7751 return builtin_options_type() == BuiltinOptions_CallOptions ? static_cast<const CallOptions *>(builtin_options()) : nullptr; 7752 } 7753 const ReshapeOptions *builtin_options_as_ReshapeOptions() const { 7754 return builtin_options_type() == BuiltinOptions_ReshapeOptions ? static_cast<const ReshapeOptions *>(builtin_options()) : nullptr; 7755 } 7756 const SkipGramOptions *builtin_options_as_SkipGramOptions() const { 7757 return builtin_options_type() == BuiltinOptions_SkipGramOptions ? static_cast<const SkipGramOptions *>(builtin_options()) : nullptr; 7758 } 7759 const SpaceToDepthOptions *builtin_options_as_SpaceToDepthOptions() const { 7760 return builtin_options_type() == BuiltinOptions_SpaceToDepthOptions ? static_cast<const SpaceToDepthOptions *>(builtin_options()) : nullptr; 7761 } 7762 const EmbeddingLookupSparseOptions *builtin_options_as_EmbeddingLookupSparseOptions() const { 7763 return builtin_options_type() == BuiltinOptions_EmbeddingLookupSparseOptions ? static_cast<const EmbeddingLookupSparseOptions *>(builtin_options()) : nullptr; 7764 } 7765 const MulOptions *builtin_options_as_MulOptions() const { 7766 return builtin_options_type() == BuiltinOptions_MulOptions ? static_cast<const MulOptions *>(builtin_options()) : nullptr; 7767 } 7768 const PadOptions *builtin_options_as_PadOptions() const { 7769 return builtin_options_type() == BuiltinOptions_PadOptions ? static_cast<const PadOptions *>(builtin_options()) : nullptr; 7770 } 7771 const GatherOptions *builtin_options_as_GatherOptions() const { 7772 return builtin_options_type() == BuiltinOptions_GatherOptions ? static_cast<const GatherOptions *>(builtin_options()) : nullptr; 7773 } 7774 const BatchToSpaceNDOptions *builtin_options_as_BatchToSpaceNDOptions() const { 7775 return builtin_options_type() == BuiltinOptions_BatchToSpaceNDOptions ? static_cast<const BatchToSpaceNDOptions *>(builtin_options()) : nullptr; 7776 } 7777 const SpaceToBatchNDOptions *builtin_options_as_SpaceToBatchNDOptions() const { 7778 return builtin_options_type() == BuiltinOptions_SpaceToBatchNDOptions ? static_cast<const SpaceToBatchNDOptions *>(builtin_options()) : nullptr; 7779 } 7780 const TransposeOptions *builtin_options_as_TransposeOptions() const { 7781 return builtin_options_type() == BuiltinOptions_TransposeOptions ? static_cast<const TransposeOptions *>(builtin_options()) : nullptr; 7782 } 7783 const ReducerOptions *builtin_options_as_ReducerOptions() const { 7784 return builtin_options_type() == BuiltinOptions_ReducerOptions ? static_cast<const ReducerOptions *>(builtin_options()) : nullptr; 7785 } 7786 const SubOptions *builtin_options_as_SubOptions() const { 7787 return builtin_options_type() == BuiltinOptions_SubOptions ? static_cast<const SubOptions *>(builtin_options()) : nullptr; 7788 } 7789 const DivOptions *builtin_options_as_DivOptions() const { 7790 return builtin_options_type() == BuiltinOptions_DivOptions ? static_cast<const DivOptions *>(builtin_options()) : nullptr; 7791 } 7792 const SqueezeOptions *builtin_options_as_SqueezeOptions() const { 7793 return builtin_options_type() == BuiltinOptions_SqueezeOptions ? static_cast<const SqueezeOptions *>(builtin_options()) : nullptr; 7794 } 7795 const SequenceRNNOptions *builtin_options_as_SequenceRNNOptions() const { 7796 return builtin_options_type() == BuiltinOptions_SequenceRNNOptions ? static_cast<const SequenceRNNOptions *>(builtin_options()) : nullptr; 7797 } 7798 const StridedSliceOptions *builtin_options_as_StridedSliceOptions() const { 7799 return builtin_options_type() == BuiltinOptions_StridedSliceOptions ? static_cast<const StridedSliceOptions *>(builtin_options()) : nullptr; 7800 } 7801 const ExpOptions *builtin_options_as_ExpOptions() const { 7802 return builtin_options_type() == BuiltinOptions_ExpOptions ? static_cast<const ExpOptions *>(builtin_options()) : nullptr; 7803 } 7804 const TopKV2Options *builtin_options_as_TopKV2Options() const { 7805 return builtin_options_type() == BuiltinOptions_TopKV2Options ? static_cast<const TopKV2Options *>(builtin_options()) : nullptr; 7806 } 7807 const SplitOptions *builtin_options_as_SplitOptions() const { 7808 return builtin_options_type() == BuiltinOptions_SplitOptions ? static_cast<const SplitOptions *>(builtin_options()) : nullptr; 7809 } 7810 const LogSoftmaxOptions *builtin_options_as_LogSoftmaxOptions() const { 7811 return builtin_options_type() == BuiltinOptions_LogSoftmaxOptions ? static_cast<const LogSoftmaxOptions *>(builtin_options()) : nullptr; 7812 } 7813 const CastOptions *builtin_options_as_CastOptions() const { 7814 return builtin_options_type() == BuiltinOptions_CastOptions ? static_cast<const CastOptions *>(builtin_options()) : nullptr; 7815 } 7816 const DequantizeOptions *builtin_options_as_DequantizeOptions() const { 7817 return builtin_options_type() == BuiltinOptions_DequantizeOptions ? static_cast<const DequantizeOptions *>(builtin_options()) : nullptr; 7818 } 7819 const MaximumMinimumOptions *builtin_options_as_MaximumMinimumOptions() const { 7820 return builtin_options_type() == BuiltinOptions_MaximumMinimumOptions ? static_cast<const MaximumMinimumOptions *>(builtin_options()) : nullptr; 7821 } 7822 const ArgMaxOptions *builtin_options_as_ArgMaxOptions() const { 7823 return builtin_options_type() == BuiltinOptions_ArgMaxOptions ? static_cast<const ArgMaxOptions *>(builtin_options()) : nullptr; 7824 } 7825 const LessOptions *builtin_options_as_LessOptions() const { 7826 return builtin_options_type() == BuiltinOptions_LessOptions ? static_cast<const LessOptions *>(builtin_options()) : nullptr; 7827 } 7828 const NegOptions *builtin_options_as_NegOptions() const { 7829 return builtin_options_type() == BuiltinOptions_NegOptions ? static_cast<const NegOptions *>(builtin_options()) : nullptr; 7830 } 7831 const PadV2Options *builtin_options_as_PadV2Options() const { 7832 return builtin_options_type() == BuiltinOptions_PadV2Options ? static_cast<const PadV2Options *>(builtin_options()) : nullptr; 7833 } 7834 const GreaterOptions *builtin_options_as_GreaterOptions() const { 7835 return builtin_options_type() == BuiltinOptions_GreaterOptions ? static_cast<const GreaterOptions *>(builtin_options()) : nullptr; 7836 } 7837 const GreaterEqualOptions *builtin_options_as_GreaterEqualOptions() const { 7838 return builtin_options_type() == BuiltinOptions_GreaterEqualOptions ? static_cast<const GreaterEqualOptions *>(builtin_options()) : nullptr; 7839 } 7840 const LessEqualOptions *builtin_options_as_LessEqualOptions() const { 7841 return builtin_options_type() == BuiltinOptions_LessEqualOptions ? static_cast<const LessEqualOptions *>(builtin_options()) : nullptr; 7842 } 7843 const SelectOptions *builtin_options_as_SelectOptions() const { 7844 return builtin_options_type() == BuiltinOptions_SelectOptions ? static_cast<const SelectOptions *>(builtin_options()) : nullptr; 7845 } 7846 const SliceOptions *builtin_options_as_SliceOptions() const { 7847 return builtin_options_type() == BuiltinOptions_SliceOptions ? static_cast<const SliceOptions *>(builtin_options()) : nullptr; 7848 } 7849 const TransposeConvOptions *builtin_options_as_TransposeConvOptions() const { 7850 return builtin_options_type() == BuiltinOptions_TransposeConvOptions ? static_cast<const TransposeConvOptions *>(builtin_options()) : nullptr; 7851 } 7852 const SparseToDenseOptions *builtin_options_as_SparseToDenseOptions() const { 7853 return builtin_options_type() == BuiltinOptions_SparseToDenseOptions ? static_cast<const SparseToDenseOptions *>(builtin_options()) : nullptr; 7854 } 7855 const TileOptions *builtin_options_as_TileOptions() const { 7856 return builtin_options_type() == BuiltinOptions_TileOptions ? static_cast<const TileOptions *>(builtin_options()) : nullptr; 7857 } 7858 const ExpandDimsOptions *builtin_options_as_ExpandDimsOptions() const { 7859 return builtin_options_type() == BuiltinOptions_ExpandDimsOptions ? static_cast<const ExpandDimsOptions *>(builtin_options()) : nullptr; 7860 } 7861 const EqualOptions *builtin_options_as_EqualOptions() const { 7862 return builtin_options_type() == BuiltinOptions_EqualOptions ? static_cast<const EqualOptions *>(builtin_options()) : nullptr; 7863 } 7864 const NotEqualOptions *builtin_options_as_NotEqualOptions() const { 7865 return builtin_options_type() == BuiltinOptions_NotEqualOptions ? static_cast<const NotEqualOptions *>(builtin_options()) : nullptr; 7866 } 7867 const ShapeOptions *builtin_options_as_ShapeOptions() const { 7868 return builtin_options_type() == BuiltinOptions_ShapeOptions ? static_cast<const ShapeOptions *>(builtin_options()) : nullptr; 7869 } 7870 const PowOptions *builtin_options_as_PowOptions() const { 7871 return builtin_options_type() == BuiltinOptions_PowOptions ? static_cast<const PowOptions *>(builtin_options()) : nullptr; 7872 } 7873 const ArgMinOptions *builtin_options_as_ArgMinOptions() const { 7874 return builtin_options_type() == BuiltinOptions_ArgMinOptions ? static_cast<const ArgMinOptions *>(builtin_options()) : nullptr; 7875 } 7876 const FakeQuantOptions *builtin_options_as_FakeQuantOptions() const { 7877 return builtin_options_type() == BuiltinOptions_FakeQuantOptions ? static_cast<const FakeQuantOptions *>(builtin_options()) : nullptr; 7878 } 7879 const PackOptions *builtin_options_as_PackOptions() const { 7880 return builtin_options_type() == BuiltinOptions_PackOptions ? static_cast<const PackOptions *>(builtin_options()) : nullptr; 7881 } 7882 const LogicalOrOptions *builtin_options_as_LogicalOrOptions() const { 7883 return builtin_options_type() == BuiltinOptions_LogicalOrOptions ? static_cast<const LogicalOrOptions *>(builtin_options()) : nullptr; 7884 } 7885 const OneHotOptions *builtin_options_as_OneHotOptions() const { 7886 return builtin_options_type() == BuiltinOptions_OneHotOptions ? static_cast<const OneHotOptions *>(builtin_options()) : nullptr; 7887 } 7888 const LogicalAndOptions *builtin_options_as_LogicalAndOptions() const { 7889 return builtin_options_type() == BuiltinOptions_LogicalAndOptions ? static_cast<const LogicalAndOptions *>(builtin_options()) : nullptr; 7890 } 7891 const LogicalNotOptions *builtin_options_as_LogicalNotOptions() const { 7892 return builtin_options_type() == BuiltinOptions_LogicalNotOptions ? static_cast<const LogicalNotOptions *>(builtin_options()) : nullptr; 7893 } 7894 const UnpackOptions *builtin_options_as_UnpackOptions() const { 7895 return builtin_options_type() == BuiltinOptions_UnpackOptions ? static_cast<const UnpackOptions *>(builtin_options()) : nullptr; 7896 } 7897 const FloorDivOptions *builtin_options_as_FloorDivOptions() const { 7898 return builtin_options_type() == BuiltinOptions_FloorDivOptions ? static_cast<const FloorDivOptions *>(builtin_options()) : nullptr; 7899 } 7900 const SquareOptions *builtin_options_as_SquareOptions() const { 7901 return builtin_options_type() == BuiltinOptions_SquareOptions ? static_cast<const SquareOptions *>(builtin_options()) : nullptr; 7902 } 7903 const ZerosLikeOptions *builtin_options_as_ZerosLikeOptions() const { 7904 return builtin_options_type() == BuiltinOptions_ZerosLikeOptions ? static_cast<const ZerosLikeOptions *>(builtin_options()) : nullptr; 7905 } 7906 const FillOptions *builtin_options_as_FillOptions() const { 7907 return builtin_options_type() == BuiltinOptions_FillOptions ? static_cast<const FillOptions *>(builtin_options()) : nullptr; 7908 } 7909 const BidirectionalSequenceLSTMOptions *builtin_options_as_BidirectionalSequenceLSTMOptions() const { 7910 return builtin_options_type() == BuiltinOptions_BidirectionalSequenceLSTMOptions ? static_cast<const BidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr; 7911 } 7912 const BidirectionalSequenceRNNOptions *builtin_options_as_BidirectionalSequenceRNNOptions() const { 7913 return builtin_options_type() == BuiltinOptions_BidirectionalSequenceRNNOptions ? static_cast<const BidirectionalSequenceRNNOptions *>(builtin_options()) : nullptr; 7914 } 7915 const UnidirectionalSequenceLSTMOptions *builtin_options_as_UnidirectionalSequenceLSTMOptions() const { 7916 return builtin_options_type() == BuiltinOptions_UnidirectionalSequenceLSTMOptions ? static_cast<const UnidirectionalSequenceLSTMOptions *>(builtin_options()) : nullptr; 7917 } 7918 const FloorModOptions *builtin_options_as_FloorModOptions() const { 7919 return builtin_options_type() == BuiltinOptions_FloorModOptions ? static_cast<const FloorModOptions *>(builtin_options()) : nullptr; 7920 } 7921 const RangeOptions *builtin_options_as_RangeOptions() const { 7922 return builtin_options_type() == BuiltinOptions_RangeOptions ? static_cast<const RangeOptions *>(builtin_options()) : nullptr; 7923 } 7924 const ResizeNearestNeighborOptions *builtin_options_as_ResizeNearestNeighborOptions() const { 7925 return builtin_options_type() == BuiltinOptions_ResizeNearestNeighborOptions ? static_cast<const ResizeNearestNeighborOptions *>(builtin_options()) : nullptr; 7926 } 7927 const LeakyReluOptions *builtin_options_as_LeakyReluOptions() const { 7928 return builtin_options_type() == BuiltinOptions_LeakyReluOptions ? static_cast<const LeakyReluOptions *>(builtin_options()) : nullptr; 7929 } 7930 const SquaredDifferenceOptions *builtin_options_as_SquaredDifferenceOptions() const { 7931 return builtin_options_type() == BuiltinOptions_SquaredDifferenceOptions ? static_cast<const SquaredDifferenceOptions *>(builtin_options()) : nullptr; 7932 } 7933 const MirrorPadOptions *builtin_options_as_MirrorPadOptions() const { 7934 return builtin_options_type() == BuiltinOptions_MirrorPadOptions ? static_cast<const MirrorPadOptions *>(builtin_options()) : nullptr; 7935 } 7936 const AbsOptions *builtin_options_as_AbsOptions() const { 7937 return builtin_options_type() == BuiltinOptions_AbsOptions ? static_cast<const AbsOptions *>(builtin_options()) : nullptr; 7938 } 7939 const SplitVOptions *builtin_options_as_SplitVOptions() const { 7940 return builtin_options_type() == BuiltinOptions_SplitVOptions ? static_cast<const SplitVOptions *>(builtin_options()) : nullptr; 7941 } 7942 const UniqueOptions *builtin_options_as_UniqueOptions() const { 7943 return builtin_options_type() == BuiltinOptions_UniqueOptions ? static_cast<const UniqueOptions *>(builtin_options()) : nullptr; 7944 } 7945 const ReverseV2Options *builtin_options_as_ReverseV2Options() const { 7946 return builtin_options_type() == BuiltinOptions_ReverseV2Options ? static_cast<const ReverseV2Options *>(builtin_options()) : nullptr; 7947 } 7948 const AddNOptions *builtin_options_as_AddNOptions() const { 7949 return builtin_options_type() == BuiltinOptions_AddNOptions ? static_cast<const AddNOptions *>(builtin_options()) : nullptr; 7950 } 7951 const GatherNdOptions *builtin_options_as_GatherNdOptions() const { 7952 return builtin_options_type() == BuiltinOptions_GatherNdOptions ? static_cast<const GatherNdOptions *>(builtin_options()) : nullptr; 7953 } 7954 const CosOptions *builtin_options_as_CosOptions() const { 7955 return builtin_options_type() == BuiltinOptions_CosOptions ? static_cast<const CosOptions *>(builtin_options()) : nullptr; 7956 } 7957 const WhereOptions *builtin_options_as_WhereOptions() const { 7958 return builtin_options_type() == BuiltinOptions_WhereOptions ? static_cast<const WhereOptions *>(builtin_options()) : nullptr; 7959 } 7960 const RankOptions *builtin_options_as_RankOptions() const { 7961 return builtin_options_type() == BuiltinOptions_RankOptions ? static_cast<const RankOptions *>(builtin_options()) : nullptr; 7962 } 7963 const ReverseSequenceOptions *builtin_options_as_ReverseSequenceOptions() const { 7964 return builtin_options_type() == BuiltinOptions_ReverseSequenceOptions ? static_cast<const ReverseSequenceOptions *>(builtin_options()) : nullptr; 7965 } 7966 const flatbuffers::Vector<uint8_t> *custom_options() const { 7967 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_CUSTOM_OPTIONS); 7968 } 7969 CustomOptionsFormat custom_options_format() const { 7970 return static_cast<CustomOptionsFormat>(GetField<int8_t>(VT_CUSTOM_OPTIONS_FORMAT, 0)); 7971 } 7972 const flatbuffers::Vector<uint8_t> *mutating_variable_inputs() const { 7973 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MUTATING_VARIABLE_INPUTS); 7974 } 7975 bool Verify(flatbuffers::Verifier &verifier) const { 7976 return VerifyTableStart(verifier) && 7977 VerifyField<uint32_t>(verifier, VT_OPCODE_INDEX) && 7978 VerifyOffset(verifier, VT_INPUTS) && 7979 verifier.VerifyVector(inputs()) && 7980 VerifyOffset(verifier, VT_OUTPUTS) && 7981 verifier.VerifyVector(outputs()) && 7982 VerifyField<uint8_t>(verifier, VT_BUILTIN_OPTIONS_TYPE) && 7983 VerifyOffset(verifier, VT_BUILTIN_OPTIONS) && 7984 VerifyBuiltinOptions(verifier, builtin_options(), builtin_options_type()) && 7985 VerifyOffset(verifier, VT_CUSTOM_OPTIONS) && 7986 verifier.VerifyVector(custom_options()) && 7987 VerifyField<int8_t>(verifier, VT_CUSTOM_OPTIONS_FORMAT) && 7988 VerifyOffset(verifier, VT_MUTATING_VARIABLE_INPUTS) && 7989 verifier.VerifyVector(mutating_variable_inputs()) && 7990 verifier.EndTable(); 7991 } 7992 OperatorT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7993 void UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 7994 static flatbuffers::Offset<Operator> Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 7995 }; 7996 7997 template<> inline const Conv2DOptions *Operator::builtin_options_as<Conv2DOptions>() const { 7998 return builtin_options_as_Conv2DOptions(); 7999 } 8000 8001 template<> inline const DepthwiseConv2DOptions *Operator::builtin_options_as<DepthwiseConv2DOptions>() const { 8002 return builtin_options_as_DepthwiseConv2DOptions(); 8003 } 8004 8005 template<> inline const ConcatEmbeddingsOptions *Operator::builtin_options_as<ConcatEmbeddingsOptions>() const { 8006 return builtin_options_as_ConcatEmbeddingsOptions(); 8007 } 8008 8009 template<> inline const LSHProjectionOptions *Operator::builtin_options_as<LSHProjectionOptions>() const { 8010 return builtin_options_as_LSHProjectionOptions(); 8011 } 8012 8013 template<> inline const Pool2DOptions *Operator::builtin_options_as<Pool2DOptions>() const { 8014 return builtin_options_as_Pool2DOptions(); 8015 } 8016 8017 template<> inline const SVDFOptions *Operator::builtin_options_as<SVDFOptions>() const { 8018 return builtin_options_as_SVDFOptions(); 8019 } 8020 8021 template<> inline const RNNOptions *Operator::builtin_options_as<RNNOptions>() const { 8022 return builtin_options_as_RNNOptions(); 8023 } 8024 8025 template<> inline const FullyConnectedOptions *Operator::builtin_options_as<FullyConnectedOptions>() const { 8026 return builtin_options_as_FullyConnectedOptions(); 8027 } 8028 8029 template<> inline const SoftmaxOptions *Operator::builtin_options_as<SoftmaxOptions>() const { 8030 return builtin_options_as_SoftmaxOptions(); 8031 } 8032 8033 template<> inline const ConcatenationOptions *Operator::builtin_options_as<ConcatenationOptions>() const { 8034 return builtin_options_as_ConcatenationOptions(); 8035 } 8036 8037 template<> inline const AddOptions *Operator::builtin_options_as<AddOptions>() const { 8038 return builtin_options_as_AddOptions(); 8039 } 8040 8041 template<> inline const L2NormOptions *Operator::builtin_options_as<L2NormOptions>() const { 8042 return builtin_options_as_L2NormOptions(); 8043 } 8044 8045 template<> inline const LocalResponseNormalizationOptions *Operator::builtin_options_as<LocalResponseNormalizationOptions>() const { 8046 return builtin_options_as_LocalResponseNormalizationOptions(); 8047 } 8048 8049 template<> inline const LSTMOptions *Operator::builtin_options_as<LSTMOptions>() const { 8050 return builtin_options_as_LSTMOptions(); 8051 } 8052 8053 template<> inline const ResizeBilinearOptions *Operator::builtin_options_as<ResizeBilinearOptions>() const { 8054 return builtin_options_as_ResizeBilinearOptions(); 8055 } 8056 8057 template<> inline const CallOptions *Operator::builtin_options_as<CallOptions>() const { 8058 return builtin_options_as_CallOptions(); 8059 } 8060 8061 template<> inline const ReshapeOptions *Operator::builtin_options_as<ReshapeOptions>() const { 8062 return builtin_options_as_ReshapeOptions(); 8063 } 8064 8065 template<> inline const SkipGramOptions *Operator::builtin_options_as<SkipGramOptions>() const { 8066 return builtin_options_as_SkipGramOptions(); 8067 } 8068 8069 template<> inline const SpaceToDepthOptions *Operator::builtin_options_as<SpaceToDepthOptions>() const { 8070 return builtin_options_as_SpaceToDepthOptions(); 8071 } 8072 8073 template<> inline const EmbeddingLookupSparseOptions *Operator::builtin_options_as<EmbeddingLookupSparseOptions>() const { 8074 return builtin_options_as_EmbeddingLookupSparseOptions(); 8075 } 8076 8077 template<> inline const MulOptions *Operator::builtin_options_as<MulOptions>() const { 8078 return builtin_options_as_MulOptions(); 8079 } 8080 8081 template<> inline const PadOptions *Operator::builtin_options_as<PadOptions>() const { 8082 return builtin_options_as_PadOptions(); 8083 } 8084 8085 template<> inline const GatherOptions *Operator::builtin_options_as<GatherOptions>() const { 8086 return builtin_options_as_GatherOptions(); 8087 } 8088 8089 template<> inline const BatchToSpaceNDOptions *Operator::builtin_options_as<BatchToSpaceNDOptions>() const { 8090 return builtin_options_as_BatchToSpaceNDOptions(); 8091 } 8092 8093 template<> inline const SpaceToBatchNDOptions *Operator::builtin_options_as<SpaceToBatchNDOptions>() const { 8094 return builtin_options_as_SpaceToBatchNDOptions(); 8095 } 8096 8097 template<> inline const TransposeOptions *Operator::builtin_options_as<TransposeOptions>() const { 8098 return builtin_options_as_TransposeOptions(); 8099 } 8100 8101 template<> inline const ReducerOptions *Operator::builtin_options_as<ReducerOptions>() const { 8102 return builtin_options_as_ReducerOptions(); 8103 } 8104 8105 template<> inline const SubOptions *Operator::builtin_options_as<SubOptions>() const { 8106 return builtin_options_as_SubOptions(); 8107 } 8108 8109 template<> inline const DivOptions *Operator::builtin_options_as<DivOptions>() const { 8110 return builtin_options_as_DivOptions(); 8111 } 8112 8113 template<> inline const SqueezeOptions *Operator::builtin_options_as<SqueezeOptions>() const { 8114 return builtin_options_as_SqueezeOptions(); 8115 } 8116 8117 template<> inline const SequenceRNNOptions *Operator::builtin_options_as<SequenceRNNOptions>() const { 8118 return builtin_options_as_SequenceRNNOptions(); 8119 } 8120 8121 template<> inline const StridedSliceOptions *Operator::builtin_options_as<StridedSliceOptions>() const { 8122 return builtin_options_as_StridedSliceOptions(); 8123 } 8124 8125 template<> inline const ExpOptions *Operator::builtin_options_as<ExpOptions>() const { 8126 return builtin_options_as_ExpOptions(); 8127 } 8128 8129 template<> inline const TopKV2Options *Operator::builtin_options_as<TopKV2Options>() const { 8130 return builtin_options_as_TopKV2Options(); 8131 } 8132 8133 template<> inline const SplitOptions *Operator::builtin_options_as<SplitOptions>() const { 8134 return builtin_options_as_SplitOptions(); 8135 } 8136 8137 template<> inline const LogSoftmaxOptions *Operator::builtin_options_as<LogSoftmaxOptions>() const { 8138 return builtin_options_as_LogSoftmaxOptions(); 8139 } 8140 8141 template<> inline const CastOptions *Operator::builtin_options_as<CastOptions>() const { 8142 return builtin_options_as_CastOptions(); 8143 } 8144 8145 template<> inline const DequantizeOptions *Operator::builtin_options_as<DequantizeOptions>() const { 8146 return builtin_options_as_DequantizeOptions(); 8147 } 8148 8149 template<> inline const MaximumMinimumOptions *Operator::builtin_options_as<MaximumMinimumOptions>() const { 8150 return builtin_options_as_MaximumMinimumOptions(); 8151 } 8152 8153 template<> inline const ArgMaxOptions *Operator::builtin_options_as<ArgMaxOptions>() const { 8154 return builtin_options_as_ArgMaxOptions(); 8155 } 8156 8157 template<> inline const LessOptions *Operator::builtin_options_as<LessOptions>() const { 8158 return builtin_options_as_LessOptions(); 8159 } 8160 8161 template<> inline const NegOptions *Operator::builtin_options_as<NegOptions>() const { 8162 return builtin_options_as_NegOptions(); 8163 } 8164 8165 template<> inline const PadV2Options *Operator::builtin_options_as<PadV2Options>() const { 8166 return builtin_options_as_PadV2Options(); 8167 } 8168 8169 template<> inline const GreaterOptions *Operator::builtin_options_as<GreaterOptions>() const { 8170 return builtin_options_as_GreaterOptions(); 8171 } 8172 8173 template<> inline const GreaterEqualOptions *Operator::builtin_options_as<GreaterEqualOptions>() const { 8174 return builtin_options_as_GreaterEqualOptions(); 8175 } 8176 8177 template<> inline const LessEqualOptions *Operator::builtin_options_as<LessEqualOptions>() const { 8178 return builtin_options_as_LessEqualOptions(); 8179 } 8180 8181 template<> inline const SelectOptions *Operator::builtin_options_as<SelectOptions>() const { 8182 return builtin_options_as_SelectOptions(); 8183 } 8184 8185 template<> inline const SliceOptions *Operator::builtin_options_as<SliceOptions>() const { 8186 return builtin_options_as_SliceOptions(); 8187 } 8188 8189 template<> inline const TransposeConvOptions *Operator::builtin_options_as<TransposeConvOptions>() const { 8190 return builtin_options_as_TransposeConvOptions(); 8191 } 8192 8193 template<> inline const SparseToDenseOptions *Operator::builtin_options_as<SparseToDenseOptions>() const { 8194 return builtin_options_as_SparseToDenseOptions(); 8195 } 8196 8197 template<> inline const TileOptions *Operator::builtin_options_as<TileOptions>() const { 8198 return builtin_options_as_TileOptions(); 8199 } 8200 8201 template<> inline const ExpandDimsOptions *Operator::builtin_options_as<ExpandDimsOptions>() const { 8202 return builtin_options_as_ExpandDimsOptions(); 8203 } 8204 8205 template<> inline const EqualOptions *Operator::builtin_options_as<EqualOptions>() const { 8206 return builtin_options_as_EqualOptions(); 8207 } 8208 8209 template<> inline const NotEqualOptions *Operator::builtin_options_as<NotEqualOptions>() const { 8210 return builtin_options_as_NotEqualOptions(); 8211 } 8212 8213 template<> inline const ShapeOptions *Operator::builtin_options_as<ShapeOptions>() const { 8214 return builtin_options_as_ShapeOptions(); 8215 } 8216 8217 template<> inline const PowOptions *Operator::builtin_options_as<PowOptions>() const { 8218 return builtin_options_as_PowOptions(); 8219 } 8220 8221 template<> inline const ArgMinOptions *Operator::builtin_options_as<ArgMinOptions>() const { 8222 return builtin_options_as_ArgMinOptions(); 8223 } 8224 8225 template<> inline const FakeQuantOptions *Operator::builtin_options_as<FakeQuantOptions>() const { 8226 return builtin_options_as_FakeQuantOptions(); 8227 } 8228 8229 template<> inline const PackOptions *Operator::builtin_options_as<PackOptions>() const { 8230 return builtin_options_as_PackOptions(); 8231 } 8232 8233 template<> inline const LogicalOrOptions *Operator::builtin_options_as<LogicalOrOptions>() const { 8234 return builtin_options_as_LogicalOrOptions(); 8235 } 8236 8237 template<> inline const OneHotOptions *Operator::builtin_options_as<OneHotOptions>() const { 8238 return builtin_options_as_OneHotOptions(); 8239 } 8240 8241 template<> inline const LogicalAndOptions *Operator::builtin_options_as<LogicalAndOptions>() const { 8242 return builtin_options_as_LogicalAndOptions(); 8243 } 8244 8245 template<> inline const LogicalNotOptions *Operator::builtin_options_as<LogicalNotOptions>() const { 8246 return builtin_options_as_LogicalNotOptions(); 8247 } 8248 8249 template<> inline const UnpackOptions *Operator::builtin_options_as<UnpackOptions>() const { 8250 return builtin_options_as_UnpackOptions(); 8251 } 8252 8253 template<> inline const FloorDivOptions *Operator::builtin_options_as<FloorDivOptions>() const { 8254 return builtin_options_as_FloorDivOptions(); 8255 } 8256 8257 template<> inline const SquareOptions *Operator::builtin_options_as<SquareOptions>() const { 8258 return builtin_options_as_SquareOptions(); 8259 } 8260 8261 template<> inline const ZerosLikeOptions *Operator::builtin_options_as<ZerosLikeOptions>() const { 8262 return builtin_options_as_ZerosLikeOptions(); 8263 } 8264 8265 template<> inline const FillOptions *Operator::builtin_options_as<FillOptions>() const { 8266 return builtin_options_as_FillOptions(); 8267 } 8268 8269 template<> inline const BidirectionalSequenceLSTMOptions *Operator::builtin_options_as<BidirectionalSequenceLSTMOptions>() const { 8270 return builtin_options_as_BidirectionalSequenceLSTMOptions(); 8271 } 8272 8273 template<> inline const BidirectionalSequenceRNNOptions *Operator::builtin_options_as<BidirectionalSequenceRNNOptions>() const { 8274 return builtin_options_as_BidirectionalSequenceRNNOptions(); 8275 } 8276 8277 template<> inline const UnidirectionalSequenceLSTMOptions *Operator::builtin_options_as<UnidirectionalSequenceLSTMOptions>() const { 8278 return builtin_options_as_UnidirectionalSequenceLSTMOptions(); 8279 } 8280 8281 template<> inline const FloorModOptions *Operator::builtin_options_as<FloorModOptions>() const { 8282 return builtin_options_as_FloorModOptions(); 8283 } 8284 8285 template<> inline const RangeOptions *Operator::builtin_options_as<RangeOptions>() const { 8286 return builtin_options_as_RangeOptions(); 8287 } 8288 8289 template<> inline const ResizeNearestNeighborOptions *Operator::builtin_options_as<ResizeNearestNeighborOptions>() const { 8290 return builtin_options_as_ResizeNearestNeighborOptions(); 8291 } 8292 8293 template<> inline const LeakyReluOptions *Operator::builtin_options_as<LeakyReluOptions>() const { 8294 return builtin_options_as_LeakyReluOptions(); 8295 } 8296 8297 template<> inline const SquaredDifferenceOptions *Operator::builtin_options_as<SquaredDifferenceOptions>() const { 8298 return builtin_options_as_SquaredDifferenceOptions(); 8299 } 8300 8301 template<> inline const MirrorPadOptions *Operator::builtin_options_as<MirrorPadOptions>() const { 8302 return builtin_options_as_MirrorPadOptions(); 8303 } 8304 8305 template<> inline const AbsOptions *Operator::builtin_options_as<AbsOptions>() const { 8306 return builtin_options_as_AbsOptions(); 8307 } 8308 8309 template<> inline const SplitVOptions *Operator::builtin_options_as<SplitVOptions>() const { 8310 return builtin_options_as_SplitVOptions(); 8311 } 8312 8313 template<> inline const UniqueOptions *Operator::builtin_options_as<UniqueOptions>() const { 8314 return builtin_options_as_UniqueOptions(); 8315 } 8316 8317 template<> inline const ReverseV2Options *Operator::builtin_options_as<ReverseV2Options>() const { 8318 return builtin_options_as_ReverseV2Options(); 8319 } 8320 8321 template<> inline const AddNOptions *Operator::builtin_options_as<AddNOptions>() const { 8322 return builtin_options_as_AddNOptions(); 8323 } 8324 8325 template<> inline const GatherNdOptions *Operator::builtin_options_as<GatherNdOptions>() const { 8326 return builtin_options_as_GatherNdOptions(); 8327 } 8328 8329 template<> inline const CosOptions *Operator::builtin_options_as<CosOptions>() const { 8330 return builtin_options_as_CosOptions(); 8331 } 8332 8333 template<> inline const WhereOptions *Operator::builtin_options_as<WhereOptions>() const { 8334 return builtin_options_as_WhereOptions(); 8335 } 8336 8337 template<> inline const RankOptions *Operator::builtin_options_as<RankOptions>() const { 8338 return builtin_options_as_RankOptions(); 8339 } 8340 8341 template<> inline const ReverseSequenceOptions *Operator::builtin_options_as<ReverseSequenceOptions>() const { 8342 return builtin_options_as_ReverseSequenceOptions(); 8343 } 8344 8345 struct OperatorBuilder { 8346 flatbuffers::FlatBufferBuilder &fbb_; 8347 flatbuffers::uoffset_t start_; 8348 void add_opcode_index(uint32_t opcode_index) { 8349 fbb_.AddElement<uint32_t>(Operator::VT_OPCODE_INDEX, opcode_index, 0); 8350 } 8351 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) { 8352 fbb_.AddOffset(Operator::VT_INPUTS, inputs); 8353 } 8354 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) { 8355 fbb_.AddOffset(Operator::VT_OUTPUTS, outputs); 8356 } 8357 void add_builtin_options_type(BuiltinOptions builtin_options_type) { 8358 fbb_.AddElement<uint8_t>(Operator::VT_BUILTIN_OPTIONS_TYPE, static_cast<uint8_t>(builtin_options_type), 0); 8359 } 8360 void add_builtin_options(flatbuffers::Offset<void> builtin_options) { 8361 fbb_.AddOffset(Operator::VT_BUILTIN_OPTIONS, builtin_options); 8362 } 8363 void add_custom_options(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options) { 8364 fbb_.AddOffset(Operator::VT_CUSTOM_OPTIONS, custom_options); 8365 } 8366 void add_custom_options_format(CustomOptionsFormat custom_options_format) { 8367 fbb_.AddElement<int8_t>(Operator::VT_CUSTOM_OPTIONS_FORMAT, static_cast<int8_t>(custom_options_format), 0); 8368 } 8369 void add_mutating_variable_inputs(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs) { 8370 fbb_.AddOffset(Operator::VT_MUTATING_VARIABLE_INPUTS, mutating_variable_inputs); 8371 } 8372 explicit OperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) 8373 : fbb_(_fbb) { 8374 start_ = fbb_.StartTable(); 8375 } 8376 OperatorBuilder &operator=(const OperatorBuilder &); 8377 flatbuffers::Offset<Operator> Finish() { 8378 const auto end = fbb_.EndTable(start_); 8379 auto o = flatbuffers::Offset<Operator>(end); 8380 return o; 8381 } 8382 }; 8383 8384 inline flatbuffers::Offset<Operator> CreateOperator( 8385 flatbuffers::FlatBufferBuilder &_fbb, 8386 uint32_t opcode_index = 0, 8387 flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0, 8388 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0, 8389 BuiltinOptions builtin_options_type = BuiltinOptions_NONE, 8390 flatbuffers::Offset<void> builtin_options = 0, 8391 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> custom_options = 0, 8392 CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS, 8393 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> mutating_variable_inputs = 0) { 8394 OperatorBuilder builder_(_fbb); 8395 builder_.add_mutating_variable_inputs(mutating_variable_inputs); 8396 builder_.add_custom_options(custom_options); 8397 builder_.add_builtin_options(builtin_options); 8398 builder_.add_outputs(outputs); 8399 builder_.add_inputs(inputs); 8400 builder_.add_opcode_index(opcode_index); 8401 builder_.add_custom_options_format(custom_options_format); 8402 builder_.add_builtin_options_type(builtin_options_type); 8403 return builder_.Finish(); 8404 } 8405 8406 inline flatbuffers::Offset<Operator> CreateOperatorDirect( 8407 flatbuffers::FlatBufferBuilder &_fbb, 8408 uint32_t opcode_index = 0, 8409 const std::vector<int32_t> *inputs = nullptr, 8410 const std::vector<int32_t> *outputs = nullptr, 8411 BuiltinOptions builtin_options_type = BuiltinOptions_NONE, 8412 flatbuffers::Offset<void> builtin_options = 0, 8413 const std::vector<uint8_t> *custom_options = nullptr, 8414 CustomOptionsFormat custom_options_format = CustomOptionsFormat_FLEXBUFFERS, 8415 const std::vector<uint8_t> *mutating_variable_inputs = nullptr) { 8416 return tflite::CreateOperator( 8417 _fbb, 8418 opcode_index, 8419 inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0, 8420 outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0, 8421 builtin_options_type, 8422 builtin_options, 8423 custom_options ? _fbb.CreateVector<uint8_t>(*custom_options) : 0, 8424 custom_options_format, 8425 mutating_variable_inputs ? _fbb.CreateVector<uint8_t>(*mutating_variable_inputs) : 0); 8426 } 8427 8428 flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 8429 8430 struct SubGraphT : public flatbuffers::NativeTable { 8431 typedef SubGraph TableType; 8432 std::vector<std::unique_ptr<TensorT>> tensors; 8433 std::vector<int32_t> inputs; 8434 std::vector<int32_t> outputs; 8435 std::vector<std::unique_ptr<OperatorT>> operators; 8436 std::string name; 8437 SubGraphT() { 8438 } 8439 }; 8440 8441 struct SubGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 8442 typedef SubGraphT NativeTableType; 8443 enum { 8444 VT_TENSORS = 4, 8445 VT_INPUTS = 6, 8446 VT_OUTPUTS = 8, 8447 VT_OPERATORS = 10, 8448 VT_NAME = 12 8449 }; 8450 const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *tensors() const { 8451 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Tensor>> *>(VT_TENSORS); 8452 } 8453 const flatbuffers::Vector<int32_t> *inputs() const { 8454 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_INPUTS); 8455 } 8456 const flatbuffers::Vector<int32_t> *outputs() const { 8457 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUTS); 8458 } 8459 const flatbuffers::Vector<flatbuffers::Offset<Operator>> *operators() const { 8460 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Operator>> *>(VT_OPERATORS); 8461 } 8462 const flatbuffers::String *name() const { 8463 return GetPointer<const flatbuffers::String *>(VT_NAME); 8464 } 8465 bool Verify(flatbuffers::Verifier &verifier) const { 8466 return VerifyTableStart(verifier) && 8467 VerifyOffset(verifier, VT_TENSORS) && 8468 verifier.VerifyVector(tensors()) && 8469 verifier.VerifyVectorOfTables(tensors()) && 8470 VerifyOffset(verifier, VT_INPUTS) && 8471 verifier.VerifyVector(inputs()) && 8472 VerifyOffset(verifier, VT_OUTPUTS) && 8473 verifier.VerifyVector(outputs()) && 8474 VerifyOffset(verifier, VT_OPERATORS) && 8475 verifier.VerifyVector(operators()) && 8476 verifier.VerifyVectorOfTables(operators()) && 8477 VerifyOffset(verifier, VT_NAME) && 8478 verifier.VerifyString(name()) && 8479 verifier.EndTable(); 8480 } 8481 SubGraphT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 8482 void UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 8483 static flatbuffers::Offset<SubGraph> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 8484 }; 8485 8486 struct SubGraphBuilder { 8487 flatbuffers::FlatBufferBuilder &fbb_; 8488 flatbuffers::uoffset_t start_; 8489 void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>> tensors) { 8490 fbb_.AddOffset(SubGraph::VT_TENSORS, tensors); 8491 } 8492 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs) { 8493 fbb_.AddOffset(SubGraph::VT_INPUTS, inputs); 8494 } 8495 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs) { 8496 fbb_.AddOffset(SubGraph::VT_OUTPUTS, outputs); 8497 } 8498 void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators) { 8499 fbb_.AddOffset(SubGraph::VT_OPERATORS, operators); 8500 } 8501 void add_name(flatbuffers::Offset<flatbuffers::String> name) { 8502 fbb_.AddOffset(SubGraph::VT_NAME, name); 8503 } 8504 explicit SubGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) 8505 : fbb_(_fbb) { 8506 start_ = fbb_.StartTable(); 8507 } 8508 SubGraphBuilder &operator=(const SubGraphBuilder &); 8509 flatbuffers::Offset<SubGraph> Finish() { 8510 const auto end = fbb_.EndTable(start_); 8511 auto o = flatbuffers::Offset<SubGraph>(end); 8512 return o; 8513 } 8514 }; 8515 8516 inline flatbuffers::Offset<SubGraph> CreateSubGraph( 8517 flatbuffers::FlatBufferBuilder &_fbb, 8518 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Tensor>>> tensors = 0, 8519 flatbuffers::Offset<flatbuffers::Vector<int32_t>> inputs = 0, 8520 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outputs = 0, 8521 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Operator>>> operators = 0, 8522 flatbuffers::Offset<flatbuffers::String> name = 0) { 8523 SubGraphBuilder builder_(_fbb); 8524 builder_.add_name(name); 8525 builder_.add_operators(operators); 8526 builder_.add_outputs(outputs); 8527 builder_.add_inputs(inputs); 8528 builder_.add_tensors(tensors); 8529 return builder_.Finish(); 8530 } 8531 8532 inline flatbuffers::Offset<SubGraph> CreateSubGraphDirect( 8533 flatbuffers::FlatBufferBuilder &_fbb, 8534 const std::vector<flatbuffers::Offset<Tensor>> *tensors = nullptr, 8535 const std::vector<int32_t> *inputs = nullptr, 8536 const std::vector<int32_t> *outputs = nullptr, 8537 const std::vector<flatbuffers::Offset<Operator>> *operators = nullptr, 8538 const char *name = nullptr) { 8539 return tflite::CreateSubGraph( 8540 _fbb, 8541 tensors ? _fbb.CreateVector<flatbuffers::Offset<Tensor>>(*tensors) : 0, 8542 inputs ? _fbb.CreateVector<int32_t>(*inputs) : 0, 8543 outputs ? _fbb.CreateVector<int32_t>(*outputs) : 0, 8544 operators ? _fbb.CreateVector<flatbuffers::Offset<Operator>>(*operators) : 0, 8545 name ? _fbb.CreateString(name) : 0); 8546 } 8547 8548 flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 8549 8550 struct BufferT : public flatbuffers::NativeTable { 8551 typedef Buffer TableType; 8552 std::vector<uint8_t> data; 8553 BufferT() { 8554 } 8555 }; 8556 8557 struct Buffer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 8558 typedef BufferT NativeTableType; 8559 enum { 8560 VT_DATA = 4 8561 }; 8562 const flatbuffers::Vector<uint8_t> *data() const { 8563 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA); 8564 } 8565 bool Verify(flatbuffers::Verifier &verifier) const { 8566 return VerifyTableStart(verifier) && 8567 VerifyOffset(verifier, VT_DATA) && 8568 verifier.VerifyVector(data()) && 8569 verifier.EndTable(); 8570 } 8571 BufferT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 8572 void UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 8573 static flatbuffers::Offset<Buffer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 8574 }; 8575 8576 struct BufferBuilder { 8577 flatbuffers::FlatBufferBuilder &fbb_; 8578 flatbuffers::uoffset_t start_; 8579 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) { 8580 fbb_.AddOffset(Buffer::VT_DATA, data); 8581 } 8582 explicit BufferBuilder(flatbuffers::FlatBufferBuilder &_fbb) 8583 : fbb_(_fbb) { 8584 start_ = fbb_.StartTable(); 8585 } 8586 BufferBuilder &operator=(const BufferBuilder &); 8587 flatbuffers::Offset<Buffer> Finish() { 8588 const auto end = fbb_.EndTable(start_); 8589 auto o = flatbuffers::Offset<Buffer>(end); 8590 return o; 8591 } 8592 }; 8593 8594 inline flatbuffers::Offset<Buffer> CreateBuffer( 8595 flatbuffers::FlatBufferBuilder &_fbb, 8596 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) { 8597 BufferBuilder builder_(_fbb); 8598 builder_.add_data(data); 8599 return builder_.Finish(); 8600 } 8601 8602 inline flatbuffers::Offset<Buffer> CreateBufferDirect( 8603 flatbuffers::FlatBufferBuilder &_fbb, 8604 const std::vector<uint8_t> *data = nullptr) { 8605 return tflite::CreateBuffer( 8606 _fbb, 8607 data ? _fbb.CreateVector<uint8_t>(*data) : 0); 8608 } 8609 8610 flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 8611 8612 struct ModelT : public flatbuffers::NativeTable { 8613 typedef Model TableType; 8614 uint32_t version; 8615 std::vector<std::unique_ptr<OperatorCodeT>> operator_codes; 8616 std::vector<std::unique_ptr<SubGraphT>> subgraphs; 8617 std::string description; 8618 std::vector<std::unique_ptr<BufferT>> buffers; 8619 std::vector<int32_t> metadata_buffer; 8620 ModelT() 8621 : version(0) { 8622 } 8623 }; 8624 8625 struct Model FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 8626 typedef ModelT NativeTableType; 8627 enum { 8628 VT_VERSION = 4, 8629 VT_OPERATOR_CODES = 6, 8630 VT_SUBGRAPHS = 8, 8631 VT_DESCRIPTION = 10, 8632 VT_BUFFERS = 12, 8633 VT_METADATA_BUFFER = 14 8634 }; 8635 uint32_t version() const { 8636 return GetField<uint32_t>(VT_VERSION, 0); 8637 } 8638 const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *operator_codes() const { 8639 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<OperatorCode>> *>(VT_OPERATOR_CODES); 8640 } 8641 const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *subgraphs() const { 8642 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<SubGraph>> *>(VT_SUBGRAPHS); 8643 } 8644 const flatbuffers::String *description() const { 8645 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION); 8646 } 8647 const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *buffers() const { 8648 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Buffer>> *>(VT_BUFFERS); 8649 } 8650 const flatbuffers::Vector<int32_t> *metadata_buffer() const { 8651 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_METADATA_BUFFER); 8652 } 8653 bool Verify(flatbuffers::Verifier &verifier) const { 8654 return VerifyTableStart(verifier) && 8655 VerifyField<uint32_t>(verifier, VT_VERSION) && 8656 VerifyOffset(verifier, VT_OPERATOR_CODES) && 8657 verifier.VerifyVector(operator_codes()) && 8658 verifier.VerifyVectorOfTables(operator_codes()) && 8659 VerifyOffset(verifier, VT_SUBGRAPHS) && 8660 verifier.VerifyVector(subgraphs()) && 8661 verifier.VerifyVectorOfTables(subgraphs()) && 8662 VerifyOffset(verifier, VT_DESCRIPTION) && 8663 verifier.VerifyString(description()) && 8664 VerifyOffset(verifier, VT_BUFFERS) && 8665 verifier.VerifyVector(buffers()) && 8666 verifier.VerifyVectorOfTables(buffers()) && 8667 VerifyOffset(verifier, VT_METADATA_BUFFER) && 8668 verifier.VerifyVector(metadata_buffer()) && 8669 verifier.EndTable(); 8670 } 8671 ModelT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 8672 void UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 8673 static flatbuffers::Offset<Model> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 8674 }; 8675 8676 struct ModelBuilder { 8677 flatbuffers::FlatBufferBuilder &fbb_; 8678 flatbuffers::uoffset_t start_; 8679 void add_version(uint32_t version) { 8680 fbb_.AddElement<uint32_t>(Model::VT_VERSION, version, 0); 8681 } 8682 void add_operator_codes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes) { 8683 fbb_.AddOffset(Model::VT_OPERATOR_CODES, operator_codes); 8684 } 8685 void add_subgraphs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs) { 8686 fbb_.AddOffset(Model::VT_SUBGRAPHS, subgraphs); 8687 } 8688 void add_description(flatbuffers::Offset<flatbuffers::String> description) { 8689 fbb_.AddOffset(Model::VT_DESCRIPTION, description); 8690 } 8691 void add_buffers(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers) { 8692 fbb_.AddOffset(Model::VT_BUFFERS, buffers); 8693 } 8694 void add_metadata_buffer(flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer) { 8695 fbb_.AddOffset(Model::VT_METADATA_BUFFER, metadata_buffer); 8696 } 8697 explicit ModelBuilder(flatbuffers::FlatBufferBuilder &_fbb) 8698 : fbb_(_fbb) { 8699 start_ = fbb_.StartTable(); 8700 } 8701 ModelBuilder &operator=(const ModelBuilder &); 8702 flatbuffers::Offset<Model> Finish() { 8703 const auto end = fbb_.EndTable(start_); 8704 auto o = flatbuffers::Offset<Model>(end); 8705 return o; 8706 } 8707 }; 8708 8709 inline flatbuffers::Offset<Model> CreateModel( 8710 flatbuffers::FlatBufferBuilder &_fbb, 8711 uint32_t version = 0, 8712 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<OperatorCode>>> operator_codes = 0, 8713 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<SubGraph>>> subgraphs = 0, 8714 flatbuffers::Offset<flatbuffers::String> description = 0, 8715 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Buffer>>> buffers = 0, 8716 flatbuffers::Offset<flatbuffers::Vector<int32_t>> metadata_buffer = 0) { 8717 ModelBuilder builder_(_fbb); 8718 builder_.add_metadata_buffer(metadata_buffer); 8719 builder_.add_buffers(buffers); 8720 builder_.add_description(description); 8721 builder_.add_subgraphs(subgraphs); 8722 builder_.add_operator_codes(operator_codes); 8723 builder_.add_version(version); 8724 return builder_.Finish(); 8725 } 8726 8727 inline flatbuffers::Offset<Model> CreateModelDirect( 8728 flatbuffers::FlatBufferBuilder &_fbb, 8729 uint32_t version = 0, 8730 const std::vector<flatbuffers::Offset<OperatorCode>> *operator_codes = nullptr, 8731 const std::vector<flatbuffers::Offset<SubGraph>> *subgraphs = nullptr, 8732 const char *description = nullptr, 8733 const std::vector<flatbuffers::Offset<Buffer>> *buffers = nullptr, 8734 const std::vector<int32_t> *metadata_buffer = nullptr) { 8735 return tflite::CreateModel( 8736 _fbb, 8737 version, 8738 operator_codes ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>>(*operator_codes) : 0, 8739 subgraphs ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>>(*subgraphs) : 0, 8740 description ? _fbb.CreateString(description) : 0, 8741 buffers ? _fbb.CreateVector<flatbuffers::Offset<Buffer>>(*buffers) : 0, 8742 metadata_buffer ? _fbb.CreateVector<int32_t>(*metadata_buffer) : 0); 8743 } 8744 8745 flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 8746 8747 inline CustomQuantizationT *CustomQuantization::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 8748 auto _o = new CustomQuantizationT(); 8749 UnPackTo(_o, _resolver); 8750 return _o; 8751 } 8752 8753 inline void CustomQuantization::UnPackTo(CustomQuantizationT *_o, const flatbuffers::resolver_function_t *_resolver) const { 8754 (void)_o; 8755 (void)_resolver; 8756 { auto _e = custom(); if (_e) { _o->custom.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->custom[_i] = _e->Get(_i); } } }; 8757 } 8758 8759 inline flatbuffers::Offset<CustomQuantization> CustomQuantization::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 8760 return CreateCustomQuantization(_fbb, _o, _rehasher); 8761 } 8762 8763 inline flatbuffers::Offset<CustomQuantization> CreateCustomQuantization(flatbuffers::FlatBufferBuilder &_fbb, const CustomQuantizationT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 8764 (void)_rehasher; 8765 (void)_o; 8766 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CustomQuantizationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 8767 auto _custom = _o->custom.size() ? _fbb.CreateVector(_o->custom) : 0; 8768 return tflite::CreateCustomQuantization( 8769 _fbb, 8770 _custom); 8771 } 8772 8773 inline QuantizationParametersT *QuantizationParameters::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 8774 auto _o = new QuantizationParametersT(); 8775 UnPackTo(_o, _resolver); 8776 return _o; 8777 } 8778 8779 inline void QuantizationParameters::UnPackTo(QuantizationParametersT *_o, const flatbuffers::resolver_function_t *_resolver) const { 8780 (void)_o; 8781 (void)_resolver; 8782 { auto _e = min(); if (_e) { _o->min.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->min[_i] = _e->Get(_i); } } }; 8783 { auto _e = max(); if (_e) { _o->max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->max[_i] = _e->Get(_i); } } }; 8784 { auto _e = scale(); if (_e) { _o->scale.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->scale[_i] = _e->Get(_i); } } }; 8785 { auto _e = zero_point(); if (_e) { _o->zero_point.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->zero_point[_i] = _e->Get(_i); } } }; 8786 { auto _e = details_type(); _o->details.type = _e; }; 8787 { auto _e = details(); if (_e) _o->details.value = QuantizationDetailsUnion::UnPack(_e, details_type(), _resolver); }; 8788 { auto _e = quantized_dimension(); _o->quantized_dimension = _e; }; 8789 } 8790 8791 inline flatbuffers::Offset<QuantizationParameters> QuantizationParameters::Pack(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 8792 return CreateQuantizationParameters(_fbb, _o, _rehasher); 8793 } 8794 8795 inline flatbuffers::Offset<QuantizationParameters> CreateQuantizationParameters(flatbuffers::FlatBufferBuilder &_fbb, const QuantizationParametersT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 8796 (void)_rehasher; 8797 (void)_o; 8798 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const QuantizationParametersT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 8799 auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0; 8800 auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0; 8801 auto _scale = _o->scale.size() ? _fbb.CreateVector(_o->scale) : 0; 8802 auto _zero_point = _o->zero_point.size() ? _fbb.CreateVector(_o->zero_point) : 0; 8803 auto _details_type = _o->details.type; 8804 auto _details = _o->details.Pack(_fbb); 8805 auto _quantized_dimension = _o->quantized_dimension; 8806 return tflite::CreateQuantizationParameters( 8807 _fbb, 8808 _min, 8809 _max, 8810 _scale, 8811 _zero_point, 8812 _details_type, 8813 _details, 8814 _quantized_dimension); 8815 } 8816 8817 inline TensorT *Tensor::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 8818 auto _o = new TensorT(); 8819 UnPackTo(_o, _resolver); 8820 return _o; 8821 } 8822 8823 inline void Tensor::UnPackTo(TensorT *_o, const flatbuffers::resolver_function_t *_resolver) const { 8824 (void)_o; 8825 (void)_resolver; 8826 { auto _e = shape(); if (_e) { _o->shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->shape[_i] = _e->Get(_i); } } }; 8827 { auto _e = type(); _o->type = _e; }; 8828 { auto _e = buffer(); _o->buffer = _e; }; 8829 { auto _e = name(); if (_e) _o->name = _e->str(); }; 8830 { auto _e = quantization(); if (_e) _o->quantization = std::unique_ptr<QuantizationParametersT>(_e->UnPack(_resolver)); }; 8831 { auto _e = is_variable(); _o->is_variable = _e; }; 8832 } 8833 8834 inline flatbuffers::Offset<Tensor> Tensor::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 8835 return CreateTensor(_fbb, _o, _rehasher); 8836 } 8837 8838 inline flatbuffers::Offset<Tensor> CreateTensor(flatbuffers::FlatBufferBuilder &_fbb, const TensorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 8839 (void)_rehasher; 8840 (void)_o; 8841 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 8842 auto _shape = _o->shape.size() ? _fbb.CreateVector(_o->shape) : 0; 8843 auto _type = _o->type; 8844 auto _buffer = _o->buffer; 8845 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); 8846 auto _quantization = _o->quantization ? CreateQuantizationParameters(_fbb, _o->quantization.get(), _rehasher) : 0; 8847 auto _is_variable = _o->is_variable; 8848 return tflite::CreateTensor( 8849 _fbb, 8850 _shape, 8851 _type, 8852 _buffer, 8853 _name, 8854 _quantization, 8855 _is_variable); 8856 } 8857 8858 inline Conv2DOptionsT *Conv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 8859 auto _o = new Conv2DOptionsT(); 8860 UnPackTo(_o, _resolver); 8861 return _o; 8862 } 8863 8864 inline void Conv2DOptions::UnPackTo(Conv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 8865 (void)_o; 8866 (void)_resolver; 8867 { auto _e = padding(); _o->padding = _e; }; 8868 { auto _e = stride_w(); _o->stride_w = _e; }; 8869 { auto _e = stride_h(); _o->stride_h = _e; }; 8870 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 8871 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }; 8872 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }; 8873 } 8874 8875 inline flatbuffers::Offset<Conv2DOptions> Conv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 8876 return CreateConv2DOptions(_fbb, _o, _rehasher); 8877 } 8878 8879 inline flatbuffers::Offset<Conv2DOptions> CreateConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Conv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 8880 (void)_rehasher; 8881 (void)_o; 8882 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Conv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 8883 auto _padding = _o->padding; 8884 auto _stride_w = _o->stride_w; 8885 auto _stride_h = _o->stride_h; 8886 auto _fused_activation_function = _o->fused_activation_function; 8887 auto _dilation_w_factor = _o->dilation_w_factor; 8888 auto _dilation_h_factor = _o->dilation_h_factor; 8889 return tflite::CreateConv2DOptions( 8890 _fbb, 8891 _padding, 8892 _stride_w, 8893 _stride_h, 8894 _fused_activation_function, 8895 _dilation_w_factor, 8896 _dilation_h_factor); 8897 } 8898 8899 inline Pool2DOptionsT *Pool2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 8900 auto _o = new Pool2DOptionsT(); 8901 UnPackTo(_o, _resolver); 8902 return _o; 8903 } 8904 8905 inline void Pool2DOptions::UnPackTo(Pool2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 8906 (void)_o; 8907 (void)_resolver; 8908 { auto _e = padding(); _o->padding = _e; }; 8909 { auto _e = stride_w(); _o->stride_w = _e; }; 8910 { auto _e = stride_h(); _o->stride_h = _e; }; 8911 { auto _e = filter_width(); _o->filter_width = _e; }; 8912 { auto _e = filter_height(); _o->filter_height = _e; }; 8913 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 8914 } 8915 8916 inline flatbuffers::Offset<Pool2DOptions> Pool2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 8917 return CreatePool2DOptions(_fbb, _o, _rehasher); 8918 } 8919 8920 inline flatbuffers::Offset<Pool2DOptions> CreatePool2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const Pool2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 8921 (void)_rehasher; 8922 (void)_o; 8923 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const Pool2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 8924 auto _padding = _o->padding; 8925 auto _stride_w = _o->stride_w; 8926 auto _stride_h = _o->stride_h; 8927 auto _filter_width = _o->filter_width; 8928 auto _filter_height = _o->filter_height; 8929 auto _fused_activation_function = _o->fused_activation_function; 8930 return tflite::CreatePool2DOptions( 8931 _fbb, 8932 _padding, 8933 _stride_w, 8934 _stride_h, 8935 _filter_width, 8936 _filter_height, 8937 _fused_activation_function); 8938 } 8939 8940 inline DepthwiseConv2DOptionsT *DepthwiseConv2DOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 8941 auto _o = new DepthwiseConv2DOptionsT(); 8942 UnPackTo(_o, _resolver); 8943 return _o; 8944 } 8945 8946 inline void DepthwiseConv2DOptions::UnPackTo(DepthwiseConv2DOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 8947 (void)_o; 8948 (void)_resolver; 8949 { auto _e = padding(); _o->padding = _e; }; 8950 { auto _e = stride_w(); _o->stride_w = _e; }; 8951 { auto _e = stride_h(); _o->stride_h = _e; }; 8952 { auto _e = depth_multiplier(); _o->depth_multiplier = _e; }; 8953 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 8954 { auto _e = dilation_w_factor(); _o->dilation_w_factor = _e; }; 8955 { auto _e = dilation_h_factor(); _o->dilation_h_factor = _e; }; 8956 } 8957 8958 inline flatbuffers::Offset<DepthwiseConv2DOptions> DepthwiseConv2DOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 8959 return CreateDepthwiseConv2DOptions(_fbb, _o, _rehasher); 8960 } 8961 8962 inline flatbuffers::Offset<DepthwiseConv2DOptions> CreateDepthwiseConv2DOptions(flatbuffers::FlatBufferBuilder &_fbb, const DepthwiseConv2DOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 8963 (void)_rehasher; 8964 (void)_o; 8965 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DepthwiseConv2DOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 8966 auto _padding = _o->padding; 8967 auto _stride_w = _o->stride_w; 8968 auto _stride_h = _o->stride_h; 8969 auto _depth_multiplier = _o->depth_multiplier; 8970 auto _fused_activation_function = _o->fused_activation_function; 8971 auto _dilation_w_factor = _o->dilation_w_factor; 8972 auto _dilation_h_factor = _o->dilation_h_factor; 8973 return tflite::CreateDepthwiseConv2DOptions( 8974 _fbb, 8975 _padding, 8976 _stride_w, 8977 _stride_h, 8978 _depth_multiplier, 8979 _fused_activation_function, 8980 _dilation_w_factor, 8981 _dilation_h_factor); 8982 } 8983 8984 inline ConcatEmbeddingsOptionsT *ConcatEmbeddingsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 8985 auto _o = new ConcatEmbeddingsOptionsT(); 8986 UnPackTo(_o, _resolver); 8987 return _o; 8988 } 8989 8990 inline void ConcatEmbeddingsOptions::UnPackTo(ConcatEmbeddingsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 8991 (void)_o; 8992 (void)_resolver; 8993 { auto _e = num_channels(); _o->num_channels = _e; }; 8994 { auto _e = num_columns_per_channel(); if (_e) { _o->num_columns_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->num_columns_per_channel[_i] = _e->Get(_i); } } }; 8995 { auto _e = embedding_dim_per_channel(); if (_e) { _o->embedding_dim_per_channel.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->embedding_dim_per_channel[_i] = _e->Get(_i); } } }; 8996 } 8997 8998 inline flatbuffers::Offset<ConcatEmbeddingsOptions> ConcatEmbeddingsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 8999 return CreateConcatEmbeddingsOptions(_fbb, _o, _rehasher); 9000 } 9001 9002 inline flatbuffers::Offset<ConcatEmbeddingsOptions> CreateConcatEmbeddingsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatEmbeddingsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9003 (void)_rehasher; 9004 (void)_o; 9005 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatEmbeddingsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9006 auto _num_channels = _o->num_channels; 9007 auto _num_columns_per_channel = _o->num_columns_per_channel.size() ? _fbb.CreateVector(_o->num_columns_per_channel) : 0; 9008 auto _embedding_dim_per_channel = _o->embedding_dim_per_channel.size() ? _fbb.CreateVector(_o->embedding_dim_per_channel) : 0; 9009 return tflite::CreateConcatEmbeddingsOptions( 9010 _fbb, 9011 _num_channels, 9012 _num_columns_per_channel, 9013 _embedding_dim_per_channel); 9014 } 9015 9016 inline LSHProjectionOptionsT *LSHProjectionOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9017 auto _o = new LSHProjectionOptionsT(); 9018 UnPackTo(_o, _resolver); 9019 return _o; 9020 } 9021 9022 inline void LSHProjectionOptions::UnPackTo(LSHProjectionOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9023 (void)_o; 9024 (void)_resolver; 9025 { auto _e = type(); _o->type = _e; }; 9026 } 9027 9028 inline flatbuffers::Offset<LSHProjectionOptions> LSHProjectionOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9029 return CreateLSHProjectionOptions(_fbb, _o, _rehasher); 9030 } 9031 9032 inline flatbuffers::Offset<LSHProjectionOptions> CreateLSHProjectionOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSHProjectionOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9033 (void)_rehasher; 9034 (void)_o; 9035 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSHProjectionOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9036 auto _type = _o->type; 9037 return tflite::CreateLSHProjectionOptions( 9038 _fbb, 9039 _type); 9040 } 9041 9042 inline SVDFOptionsT *SVDFOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9043 auto _o = new SVDFOptionsT(); 9044 UnPackTo(_o, _resolver); 9045 return _o; 9046 } 9047 9048 inline void SVDFOptions::UnPackTo(SVDFOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9049 (void)_o; 9050 (void)_resolver; 9051 { auto _e = rank(); _o->rank = _e; }; 9052 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9053 } 9054 9055 inline flatbuffers::Offset<SVDFOptions> SVDFOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9056 return CreateSVDFOptions(_fbb, _o, _rehasher); 9057 } 9058 9059 inline flatbuffers::Offset<SVDFOptions> CreateSVDFOptions(flatbuffers::FlatBufferBuilder &_fbb, const SVDFOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9060 (void)_rehasher; 9061 (void)_o; 9062 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SVDFOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9063 auto _rank = _o->rank; 9064 auto _fused_activation_function = _o->fused_activation_function; 9065 return tflite::CreateSVDFOptions( 9066 _fbb, 9067 _rank, 9068 _fused_activation_function); 9069 } 9070 9071 inline RNNOptionsT *RNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9072 auto _o = new RNNOptionsT(); 9073 UnPackTo(_o, _resolver); 9074 return _o; 9075 } 9076 9077 inline void RNNOptions::UnPackTo(RNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9078 (void)_o; 9079 (void)_resolver; 9080 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9081 } 9082 9083 inline flatbuffers::Offset<RNNOptions> RNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9084 return CreateRNNOptions(_fbb, _o, _rehasher); 9085 } 9086 9087 inline flatbuffers::Offset<RNNOptions> CreateRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const RNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9088 (void)_rehasher; 9089 (void)_o; 9090 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9091 auto _fused_activation_function = _o->fused_activation_function; 9092 return tflite::CreateRNNOptions( 9093 _fbb, 9094 _fused_activation_function); 9095 } 9096 9097 inline SequenceRNNOptionsT *SequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9098 auto _o = new SequenceRNNOptionsT(); 9099 UnPackTo(_o, _resolver); 9100 return _o; 9101 } 9102 9103 inline void SequenceRNNOptions::UnPackTo(SequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9104 (void)_o; 9105 (void)_resolver; 9106 { auto _e = time_major(); _o->time_major = _e; }; 9107 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9108 } 9109 9110 inline flatbuffers::Offset<SequenceRNNOptions> SequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9111 return CreateSequenceRNNOptions(_fbb, _o, _rehasher); 9112 } 9113 9114 inline flatbuffers::Offset<SequenceRNNOptions> CreateSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const SequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9115 (void)_rehasher; 9116 (void)_o; 9117 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9118 auto _time_major = _o->time_major; 9119 auto _fused_activation_function = _o->fused_activation_function; 9120 return tflite::CreateSequenceRNNOptions( 9121 _fbb, 9122 _time_major, 9123 _fused_activation_function); 9124 } 9125 9126 inline BidirectionalSequenceRNNOptionsT *BidirectionalSequenceRNNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9127 auto _o = new BidirectionalSequenceRNNOptionsT(); 9128 UnPackTo(_o, _resolver); 9129 return _o; 9130 } 9131 9132 inline void BidirectionalSequenceRNNOptions::UnPackTo(BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9133 (void)_o; 9134 (void)_resolver; 9135 { auto _e = time_major(); _o->time_major = _e; }; 9136 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9137 { auto _e = merge_outputs(); _o->merge_outputs = _e; }; 9138 } 9139 9140 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> BidirectionalSequenceRNNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9141 return CreateBidirectionalSequenceRNNOptions(_fbb, _o, _rehasher); 9142 } 9143 9144 inline flatbuffers::Offset<BidirectionalSequenceRNNOptions> CreateBidirectionalSequenceRNNOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceRNNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9145 (void)_rehasher; 9146 (void)_o; 9147 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceRNNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9148 auto _time_major = _o->time_major; 9149 auto _fused_activation_function = _o->fused_activation_function; 9150 auto _merge_outputs = _o->merge_outputs; 9151 return tflite::CreateBidirectionalSequenceRNNOptions( 9152 _fbb, 9153 _time_major, 9154 _fused_activation_function, 9155 _merge_outputs); 9156 } 9157 9158 inline FullyConnectedOptionsT *FullyConnectedOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9159 auto _o = new FullyConnectedOptionsT(); 9160 UnPackTo(_o, _resolver); 9161 return _o; 9162 } 9163 9164 inline void FullyConnectedOptions::UnPackTo(FullyConnectedOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9165 (void)_o; 9166 (void)_resolver; 9167 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9168 { auto _e = weights_format(); _o->weights_format = _e; }; 9169 } 9170 9171 inline flatbuffers::Offset<FullyConnectedOptions> FullyConnectedOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9172 return CreateFullyConnectedOptions(_fbb, _o, _rehasher); 9173 } 9174 9175 inline flatbuffers::Offset<FullyConnectedOptions> CreateFullyConnectedOptions(flatbuffers::FlatBufferBuilder &_fbb, const FullyConnectedOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9176 (void)_rehasher; 9177 (void)_o; 9178 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FullyConnectedOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9179 auto _fused_activation_function = _o->fused_activation_function; 9180 auto _weights_format = _o->weights_format; 9181 return tflite::CreateFullyConnectedOptions( 9182 _fbb, 9183 _fused_activation_function, 9184 _weights_format); 9185 } 9186 9187 inline SoftmaxOptionsT *SoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9188 auto _o = new SoftmaxOptionsT(); 9189 UnPackTo(_o, _resolver); 9190 return _o; 9191 } 9192 9193 inline void SoftmaxOptions::UnPackTo(SoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9194 (void)_o; 9195 (void)_resolver; 9196 { auto _e = beta(); _o->beta = _e; }; 9197 } 9198 9199 inline flatbuffers::Offset<SoftmaxOptions> SoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9200 return CreateSoftmaxOptions(_fbb, _o, _rehasher); 9201 } 9202 9203 inline flatbuffers::Offset<SoftmaxOptions> CreateSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const SoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9204 (void)_rehasher; 9205 (void)_o; 9206 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9207 auto _beta = _o->beta; 9208 return tflite::CreateSoftmaxOptions( 9209 _fbb, 9210 _beta); 9211 } 9212 9213 inline ConcatenationOptionsT *ConcatenationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9214 auto _o = new ConcatenationOptionsT(); 9215 UnPackTo(_o, _resolver); 9216 return _o; 9217 } 9218 9219 inline void ConcatenationOptions::UnPackTo(ConcatenationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9220 (void)_o; 9221 (void)_resolver; 9222 { auto _e = axis(); _o->axis = _e; }; 9223 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9224 } 9225 9226 inline flatbuffers::Offset<ConcatenationOptions> ConcatenationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9227 return CreateConcatenationOptions(_fbb, _o, _rehasher); 9228 } 9229 9230 inline flatbuffers::Offset<ConcatenationOptions> CreateConcatenationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ConcatenationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9231 (void)_rehasher; 9232 (void)_o; 9233 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConcatenationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9234 auto _axis = _o->axis; 9235 auto _fused_activation_function = _o->fused_activation_function; 9236 return tflite::CreateConcatenationOptions( 9237 _fbb, 9238 _axis, 9239 _fused_activation_function); 9240 } 9241 9242 inline AddOptionsT *AddOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9243 auto _o = new AddOptionsT(); 9244 UnPackTo(_o, _resolver); 9245 return _o; 9246 } 9247 9248 inline void AddOptions::UnPackTo(AddOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9249 (void)_o; 9250 (void)_resolver; 9251 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9252 } 9253 9254 inline flatbuffers::Offset<AddOptions> AddOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9255 return CreateAddOptions(_fbb, _o, _rehasher); 9256 } 9257 9258 inline flatbuffers::Offset<AddOptions> CreateAddOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9259 (void)_rehasher; 9260 (void)_o; 9261 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9262 auto _fused_activation_function = _o->fused_activation_function; 9263 return tflite::CreateAddOptions( 9264 _fbb, 9265 _fused_activation_function); 9266 } 9267 9268 inline MulOptionsT *MulOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9269 auto _o = new MulOptionsT(); 9270 UnPackTo(_o, _resolver); 9271 return _o; 9272 } 9273 9274 inline void MulOptions::UnPackTo(MulOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9275 (void)_o; 9276 (void)_resolver; 9277 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9278 } 9279 9280 inline flatbuffers::Offset<MulOptions> MulOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9281 return CreateMulOptions(_fbb, _o, _rehasher); 9282 } 9283 9284 inline flatbuffers::Offset<MulOptions> CreateMulOptions(flatbuffers::FlatBufferBuilder &_fbb, const MulOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9285 (void)_rehasher; 9286 (void)_o; 9287 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MulOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9288 auto _fused_activation_function = _o->fused_activation_function; 9289 return tflite::CreateMulOptions( 9290 _fbb, 9291 _fused_activation_function); 9292 } 9293 9294 inline L2NormOptionsT *L2NormOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9295 auto _o = new L2NormOptionsT(); 9296 UnPackTo(_o, _resolver); 9297 return _o; 9298 } 9299 9300 inline void L2NormOptions::UnPackTo(L2NormOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9301 (void)_o; 9302 (void)_resolver; 9303 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9304 } 9305 9306 inline flatbuffers::Offset<L2NormOptions> L2NormOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9307 return CreateL2NormOptions(_fbb, _o, _rehasher); 9308 } 9309 9310 inline flatbuffers::Offset<L2NormOptions> CreateL2NormOptions(flatbuffers::FlatBufferBuilder &_fbb, const L2NormOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9311 (void)_rehasher; 9312 (void)_o; 9313 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const L2NormOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9314 auto _fused_activation_function = _o->fused_activation_function; 9315 return tflite::CreateL2NormOptions( 9316 _fbb, 9317 _fused_activation_function); 9318 } 9319 9320 inline LocalResponseNormalizationOptionsT *LocalResponseNormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9321 auto _o = new LocalResponseNormalizationOptionsT(); 9322 UnPackTo(_o, _resolver); 9323 return _o; 9324 } 9325 9326 inline void LocalResponseNormalizationOptions::UnPackTo(LocalResponseNormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9327 (void)_o; 9328 (void)_resolver; 9329 { auto _e = radius(); _o->radius = _e; }; 9330 { auto _e = bias(); _o->bias = _e; }; 9331 { auto _e = alpha(); _o->alpha = _e; }; 9332 { auto _e = beta(); _o->beta = _e; }; 9333 } 9334 9335 inline flatbuffers::Offset<LocalResponseNormalizationOptions> LocalResponseNormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9336 return CreateLocalResponseNormalizationOptions(_fbb, _o, _rehasher); 9337 } 9338 9339 inline flatbuffers::Offset<LocalResponseNormalizationOptions> CreateLocalResponseNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const LocalResponseNormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9340 (void)_rehasher; 9341 (void)_o; 9342 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LocalResponseNormalizationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9343 auto _radius = _o->radius; 9344 auto _bias = _o->bias; 9345 auto _alpha = _o->alpha; 9346 auto _beta = _o->beta; 9347 return tflite::CreateLocalResponseNormalizationOptions( 9348 _fbb, 9349 _radius, 9350 _bias, 9351 _alpha, 9352 _beta); 9353 } 9354 9355 inline LSTMOptionsT *LSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9356 auto _o = new LSTMOptionsT(); 9357 UnPackTo(_o, _resolver); 9358 return _o; 9359 } 9360 9361 inline void LSTMOptions::UnPackTo(LSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9362 (void)_o; 9363 (void)_resolver; 9364 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9365 { auto _e = cell_clip(); _o->cell_clip = _e; }; 9366 { auto _e = proj_clip(); _o->proj_clip = _e; }; 9367 { auto _e = kernel_type(); _o->kernel_type = _e; }; 9368 } 9369 9370 inline flatbuffers::Offset<LSTMOptions> LSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9371 return CreateLSTMOptions(_fbb, _o, _rehasher); 9372 } 9373 9374 inline flatbuffers::Offset<LSTMOptions> CreateLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const LSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9375 (void)_rehasher; 9376 (void)_o; 9377 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9378 auto _fused_activation_function = _o->fused_activation_function; 9379 auto _cell_clip = _o->cell_clip; 9380 auto _proj_clip = _o->proj_clip; 9381 auto _kernel_type = _o->kernel_type; 9382 return tflite::CreateLSTMOptions( 9383 _fbb, 9384 _fused_activation_function, 9385 _cell_clip, 9386 _proj_clip, 9387 _kernel_type); 9388 } 9389 9390 inline UnidirectionalSequenceLSTMOptionsT *UnidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9391 auto _o = new UnidirectionalSequenceLSTMOptionsT(); 9392 UnPackTo(_o, _resolver); 9393 return _o; 9394 } 9395 9396 inline void UnidirectionalSequenceLSTMOptions::UnPackTo(UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9397 (void)_o; 9398 (void)_resolver; 9399 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9400 { auto _e = cell_clip(); _o->cell_clip = _e; }; 9401 { auto _e = proj_clip(); _o->proj_clip = _e; }; 9402 { auto _e = time_major(); _o->time_major = _e; }; 9403 } 9404 9405 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> UnidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9406 return CreateUnidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher); 9407 } 9408 9409 inline flatbuffers::Offset<UnidirectionalSequenceLSTMOptions> CreateUnidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9410 (void)_rehasher; 9411 (void)_o; 9412 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9413 auto _fused_activation_function = _o->fused_activation_function; 9414 auto _cell_clip = _o->cell_clip; 9415 auto _proj_clip = _o->proj_clip; 9416 auto _time_major = _o->time_major; 9417 return tflite::CreateUnidirectionalSequenceLSTMOptions( 9418 _fbb, 9419 _fused_activation_function, 9420 _cell_clip, 9421 _proj_clip, 9422 _time_major); 9423 } 9424 9425 inline BidirectionalSequenceLSTMOptionsT *BidirectionalSequenceLSTMOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9426 auto _o = new BidirectionalSequenceLSTMOptionsT(); 9427 UnPackTo(_o, _resolver); 9428 return _o; 9429 } 9430 9431 inline void BidirectionalSequenceLSTMOptions::UnPackTo(BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9432 (void)_o; 9433 (void)_resolver; 9434 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9435 { auto _e = cell_clip(); _o->cell_clip = _e; }; 9436 { auto _e = proj_clip(); _o->proj_clip = _e; }; 9437 { auto _e = merge_outputs(); _o->merge_outputs = _e; }; 9438 { auto _e = time_major(); _o->time_major = _e; }; 9439 } 9440 9441 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> BidirectionalSequenceLSTMOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9442 return CreateBidirectionalSequenceLSTMOptions(_fbb, _o, _rehasher); 9443 } 9444 9445 inline flatbuffers::Offset<BidirectionalSequenceLSTMOptions> CreateBidirectionalSequenceLSTMOptions(flatbuffers::FlatBufferBuilder &_fbb, const BidirectionalSequenceLSTMOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9446 (void)_rehasher; 9447 (void)_o; 9448 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BidirectionalSequenceLSTMOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9449 auto _fused_activation_function = _o->fused_activation_function; 9450 auto _cell_clip = _o->cell_clip; 9451 auto _proj_clip = _o->proj_clip; 9452 auto _merge_outputs = _o->merge_outputs; 9453 auto _time_major = _o->time_major; 9454 return tflite::CreateBidirectionalSequenceLSTMOptions( 9455 _fbb, 9456 _fused_activation_function, 9457 _cell_clip, 9458 _proj_clip, 9459 _merge_outputs, 9460 _time_major); 9461 } 9462 9463 inline ResizeBilinearOptionsT *ResizeBilinearOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9464 auto _o = new ResizeBilinearOptionsT(); 9465 UnPackTo(_o, _resolver); 9466 return _o; 9467 } 9468 9469 inline void ResizeBilinearOptions::UnPackTo(ResizeBilinearOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9470 (void)_o; 9471 (void)_resolver; 9472 { auto _e = align_corners(); _o->align_corners = _e; }; 9473 } 9474 9475 inline flatbuffers::Offset<ResizeBilinearOptions> ResizeBilinearOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9476 return CreateResizeBilinearOptions(_fbb, _o, _rehasher); 9477 } 9478 9479 inline flatbuffers::Offset<ResizeBilinearOptions> CreateResizeBilinearOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeBilinearOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9480 (void)_rehasher; 9481 (void)_o; 9482 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeBilinearOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9483 auto _align_corners = _o->align_corners; 9484 return tflite::CreateResizeBilinearOptions( 9485 _fbb, 9486 _align_corners); 9487 } 9488 9489 inline ResizeNearestNeighborOptionsT *ResizeNearestNeighborOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9490 auto _o = new ResizeNearestNeighborOptionsT(); 9491 UnPackTo(_o, _resolver); 9492 return _o; 9493 } 9494 9495 inline void ResizeNearestNeighborOptions::UnPackTo(ResizeNearestNeighborOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9496 (void)_o; 9497 (void)_resolver; 9498 { auto _e = align_corners(); _o->align_corners = _e; }; 9499 } 9500 9501 inline flatbuffers::Offset<ResizeNearestNeighborOptions> ResizeNearestNeighborOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9502 return CreateResizeNearestNeighborOptions(_fbb, _o, _rehasher); 9503 } 9504 9505 inline flatbuffers::Offset<ResizeNearestNeighborOptions> CreateResizeNearestNeighborOptions(flatbuffers::FlatBufferBuilder &_fbb, const ResizeNearestNeighborOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9506 (void)_rehasher; 9507 (void)_o; 9508 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ResizeNearestNeighborOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9509 auto _align_corners = _o->align_corners; 9510 return tflite::CreateResizeNearestNeighborOptions( 9511 _fbb, 9512 _align_corners); 9513 } 9514 9515 inline CallOptionsT *CallOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9516 auto _o = new CallOptionsT(); 9517 UnPackTo(_o, _resolver); 9518 return _o; 9519 } 9520 9521 inline void CallOptions::UnPackTo(CallOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9522 (void)_o; 9523 (void)_resolver; 9524 { auto _e = subgraph(); _o->subgraph = _e; }; 9525 } 9526 9527 inline flatbuffers::Offset<CallOptions> CallOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9528 return CreateCallOptions(_fbb, _o, _rehasher); 9529 } 9530 9531 inline flatbuffers::Offset<CallOptions> CreateCallOptions(flatbuffers::FlatBufferBuilder &_fbb, const CallOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9532 (void)_rehasher; 9533 (void)_o; 9534 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9535 auto _subgraph = _o->subgraph; 9536 return tflite::CreateCallOptions( 9537 _fbb, 9538 _subgraph); 9539 } 9540 9541 inline PadOptionsT *PadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9542 auto _o = new PadOptionsT(); 9543 UnPackTo(_o, _resolver); 9544 return _o; 9545 } 9546 9547 inline void PadOptions::UnPackTo(PadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9548 (void)_o; 9549 (void)_resolver; 9550 } 9551 9552 inline flatbuffers::Offset<PadOptions> PadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9553 return CreatePadOptions(_fbb, _o, _rehasher); 9554 } 9555 9556 inline flatbuffers::Offset<PadOptions> CreatePadOptions(flatbuffers::FlatBufferBuilder &_fbb, const PadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9557 (void)_rehasher; 9558 (void)_o; 9559 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9560 return tflite::CreatePadOptions( 9561 _fbb); 9562 } 9563 9564 inline PadV2OptionsT *PadV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9565 auto _o = new PadV2OptionsT(); 9566 UnPackTo(_o, _resolver); 9567 return _o; 9568 } 9569 9570 inline void PadV2Options::UnPackTo(PadV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9571 (void)_o; 9572 (void)_resolver; 9573 } 9574 9575 inline flatbuffers::Offset<PadV2Options> PadV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9576 return CreatePadV2Options(_fbb, _o, _rehasher); 9577 } 9578 9579 inline flatbuffers::Offset<PadV2Options> CreatePadV2Options(flatbuffers::FlatBufferBuilder &_fbb, const PadV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9580 (void)_rehasher; 9581 (void)_o; 9582 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PadV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9583 return tflite::CreatePadV2Options( 9584 _fbb); 9585 } 9586 9587 inline ReshapeOptionsT *ReshapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9588 auto _o = new ReshapeOptionsT(); 9589 UnPackTo(_o, _resolver); 9590 return _o; 9591 } 9592 9593 inline void ReshapeOptions::UnPackTo(ReshapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9594 (void)_o; 9595 (void)_resolver; 9596 { auto _e = new_shape(); if (_e) { _o->new_shape.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_shape[_i] = _e->Get(_i); } } }; 9597 } 9598 9599 inline flatbuffers::Offset<ReshapeOptions> ReshapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9600 return CreateReshapeOptions(_fbb, _o, _rehasher); 9601 } 9602 9603 inline flatbuffers::Offset<ReshapeOptions> CreateReshapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReshapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9604 (void)_rehasher; 9605 (void)_o; 9606 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReshapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9607 auto _new_shape = _o->new_shape.size() ? _fbb.CreateVector(_o->new_shape) : 0; 9608 return tflite::CreateReshapeOptions( 9609 _fbb, 9610 _new_shape); 9611 } 9612 9613 inline SpaceToBatchNDOptionsT *SpaceToBatchNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9614 auto _o = new SpaceToBatchNDOptionsT(); 9615 UnPackTo(_o, _resolver); 9616 return _o; 9617 } 9618 9619 inline void SpaceToBatchNDOptions::UnPackTo(SpaceToBatchNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9620 (void)_o; 9621 (void)_resolver; 9622 } 9623 9624 inline flatbuffers::Offset<SpaceToBatchNDOptions> SpaceToBatchNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9625 return CreateSpaceToBatchNDOptions(_fbb, _o, _rehasher); 9626 } 9627 9628 inline flatbuffers::Offset<SpaceToBatchNDOptions> CreateSpaceToBatchNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToBatchNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9629 (void)_rehasher; 9630 (void)_o; 9631 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToBatchNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9632 return tflite::CreateSpaceToBatchNDOptions( 9633 _fbb); 9634 } 9635 9636 inline BatchToSpaceNDOptionsT *BatchToSpaceNDOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9637 auto _o = new BatchToSpaceNDOptionsT(); 9638 UnPackTo(_o, _resolver); 9639 return _o; 9640 } 9641 9642 inline void BatchToSpaceNDOptions::UnPackTo(BatchToSpaceNDOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9643 (void)_o; 9644 (void)_resolver; 9645 } 9646 9647 inline flatbuffers::Offset<BatchToSpaceNDOptions> BatchToSpaceNDOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9648 return CreateBatchToSpaceNDOptions(_fbb, _o, _rehasher); 9649 } 9650 9651 inline flatbuffers::Offset<BatchToSpaceNDOptions> CreateBatchToSpaceNDOptions(flatbuffers::FlatBufferBuilder &_fbb, const BatchToSpaceNDOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9652 (void)_rehasher; 9653 (void)_o; 9654 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BatchToSpaceNDOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9655 return tflite::CreateBatchToSpaceNDOptions( 9656 _fbb); 9657 } 9658 9659 inline SkipGramOptionsT *SkipGramOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9660 auto _o = new SkipGramOptionsT(); 9661 UnPackTo(_o, _resolver); 9662 return _o; 9663 } 9664 9665 inline void SkipGramOptions::UnPackTo(SkipGramOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9666 (void)_o; 9667 (void)_resolver; 9668 { auto _e = ngram_size(); _o->ngram_size = _e; }; 9669 { auto _e = max_skip_size(); _o->max_skip_size = _e; }; 9670 { auto _e = include_all_ngrams(); _o->include_all_ngrams = _e; }; 9671 } 9672 9673 inline flatbuffers::Offset<SkipGramOptions> SkipGramOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9674 return CreateSkipGramOptions(_fbb, _o, _rehasher); 9675 } 9676 9677 inline flatbuffers::Offset<SkipGramOptions> CreateSkipGramOptions(flatbuffers::FlatBufferBuilder &_fbb, const SkipGramOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9678 (void)_rehasher; 9679 (void)_o; 9680 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SkipGramOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9681 auto _ngram_size = _o->ngram_size; 9682 auto _max_skip_size = _o->max_skip_size; 9683 auto _include_all_ngrams = _o->include_all_ngrams; 9684 return tflite::CreateSkipGramOptions( 9685 _fbb, 9686 _ngram_size, 9687 _max_skip_size, 9688 _include_all_ngrams); 9689 } 9690 9691 inline SpaceToDepthOptionsT *SpaceToDepthOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9692 auto _o = new SpaceToDepthOptionsT(); 9693 UnPackTo(_o, _resolver); 9694 return _o; 9695 } 9696 9697 inline void SpaceToDepthOptions::UnPackTo(SpaceToDepthOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9698 (void)_o; 9699 (void)_resolver; 9700 { auto _e = block_size(); _o->block_size = _e; }; 9701 } 9702 9703 inline flatbuffers::Offset<SpaceToDepthOptions> SpaceToDepthOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9704 return CreateSpaceToDepthOptions(_fbb, _o, _rehasher); 9705 } 9706 9707 inline flatbuffers::Offset<SpaceToDepthOptions> CreateSpaceToDepthOptions(flatbuffers::FlatBufferBuilder &_fbb, const SpaceToDepthOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9708 (void)_rehasher; 9709 (void)_o; 9710 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SpaceToDepthOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9711 auto _block_size = _o->block_size; 9712 return tflite::CreateSpaceToDepthOptions( 9713 _fbb, 9714 _block_size); 9715 } 9716 9717 inline SubOptionsT *SubOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9718 auto _o = new SubOptionsT(); 9719 UnPackTo(_o, _resolver); 9720 return _o; 9721 } 9722 9723 inline void SubOptions::UnPackTo(SubOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9724 (void)_o; 9725 (void)_resolver; 9726 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9727 } 9728 9729 inline flatbuffers::Offset<SubOptions> SubOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9730 return CreateSubOptions(_fbb, _o, _rehasher); 9731 } 9732 9733 inline flatbuffers::Offset<SubOptions> CreateSubOptions(flatbuffers::FlatBufferBuilder &_fbb, const SubOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9734 (void)_rehasher; 9735 (void)_o; 9736 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9737 auto _fused_activation_function = _o->fused_activation_function; 9738 return tflite::CreateSubOptions( 9739 _fbb, 9740 _fused_activation_function); 9741 } 9742 9743 inline DivOptionsT *DivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9744 auto _o = new DivOptionsT(); 9745 UnPackTo(_o, _resolver); 9746 return _o; 9747 } 9748 9749 inline void DivOptions::UnPackTo(DivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9750 (void)_o; 9751 (void)_resolver; 9752 { auto _e = fused_activation_function(); _o->fused_activation_function = _e; }; 9753 } 9754 9755 inline flatbuffers::Offset<DivOptions> DivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9756 return CreateDivOptions(_fbb, _o, _rehasher); 9757 } 9758 9759 inline flatbuffers::Offset<DivOptions> CreateDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const DivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9760 (void)_rehasher; 9761 (void)_o; 9762 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9763 auto _fused_activation_function = _o->fused_activation_function; 9764 return tflite::CreateDivOptions( 9765 _fbb, 9766 _fused_activation_function); 9767 } 9768 9769 inline TopKV2OptionsT *TopKV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9770 auto _o = new TopKV2OptionsT(); 9771 UnPackTo(_o, _resolver); 9772 return _o; 9773 } 9774 9775 inline void TopKV2Options::UnPackTo(TopKV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9776 (void)_o; 9777 (void)_resolver; 9778 } 9779 9780 inline flatbuffers::Offset<TopKV2Options> TopKV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9781 return CreateTopKV2Options(_fbb, _o, _rehasher); 9782 } 9783 9784 inline flatbuffers::Offset<TopKV2Options> CreateTopKV2Options(flatbuffers::FlatBufferBuilder &_fbb, const TopKV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9785 (void)_rehasher; 9786 (void)_o; 9787 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TopKV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9788 return tflite::CreateTopKV2Options( 9789 _fbb); 9790 } 9791 9792 inline EmbeddingLookupSparseOptionsT *EmbeddingLookupSparseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9793 auto _o = new EmbeddingLookupSparseOptionsT(); 9794 UnPackTo(_o, _resolver); 9795 return _o; 9796 } 9797 9798 inline void EmbeddingLookupSparseOptions::UnPackTo(EmbeddingLookupSparseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9799 (void)_o; 9800 (void)_resolver; 9801 { auto _e = combiner(); _o->combiner = _e; }; 9802 } 9803 9804 inline flatbuffers::Offset<EmbeddingLookupSparseOptions> EmbeddingLookupSparseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9805 return CreateEmbeddingLookupSparseOptions(_fbb, _o, _rehasher); 9806 } 9807 9808 inline flatbuffers::Offset<EmbeddingLookupSparseOptions> CreateEmbeddingLookupSparseOptions(flatbuffers::FlatBufferBuilder &_fbb, const EmbeddingLookupSparseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9809 (void)_rehasher; 9810 (void)_o; 9811 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EmbeddingLookupSparseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9812 auto _combiner = _o->combiner; 9813 return tflite::CreateEmbeddingLookupSparseOptions( 9814 _fbb, 9815 _combiner); 9816 } 9817 9818 inline GatherOptionsT *GatherOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9819 auto _o = new GatherOptionsT(); 9820 UnPackTo(_o, _resolver); 9821 return _o; 9822 } 9823 9824 inline void GatherOptions::UnPackTo(GatherOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9825 (void)_o; 9826 (void)_resolver; 9827 { auto _e = axis(); _o->axis = _e; }; 9828 } 9829 9830 inline flatbuffers::Offset<GatherOptions> GatherOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9831 return CreateGatherOptions(_fbb, _o, _rehasher); 9832 } 9833 9834 inline flatbuffers::Offset<GatherOptions> CreateGatherOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9835 (void)_rehasher; 9836 (void)_o; 9837 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9838 auto _axis = _o->axis; 9839 return tflite::CreateGatherOptions( 9840 _fbb, 9841 _axis); 9842 } 9843 9844 inline TransposeOptionsT *TransposeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9845 auto _o = new TransposeOptionsT(); 9846 UnPackTo(_o, _resolver); 9847 return _o; 9848 } 9849 9850 inline void TransposeOptions::UnPackTo(TransposeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9851 (void)_o; 9852 (void)_resolver; 9853 } 9854 9855 inline flatbuffers::Offset<TransposeOptions> TransposeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9856 return CreateTransposeOptions(_fbb, _o, _rehasher); 9857 } 9858 9859 inline flatbuffers::Offset<TransposeOptions> CreateTransposeOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9860 (void)_rehasher; 9861 (void)_o; 9862 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9863 return tflite::CreateTransposeOptions( 9864 _fbb); 9865 } 9866 9867 inline ExpOptionsT *ExpOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9868 auto _o = new ExpOptionsT(); 9869 UnPackTo(_o, _resolver); 9870 return _o; 9871 } 9872 9873 inline void ExpOptions::UnPackTo(ExpOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9874 (void)_o; 9875 (void)_resolver; 9876 } 9877 9878 inline flatbuffers::Offset<ExpOptions> ExpOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9879 return CreateExpOptions(_fbb, _o, _rehasher); 9880 } 9881 9882 inline flatbuffers::Offset<ExpOptions> CreateExpOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9883 (void)_rehasher; 9884 (void)_o; 9885 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9886 return tflite::CreateExpOptions( 9887 _fbb); 9888 } 9889 9890 inline CosOptionsT *CosOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9891 auto _o = new CosOptionsT(); 9892 UnPackTo(_o, _resolver); 9893 return _o; 9894 } 9895 9896 inline void CosOptions::UnPackTo(CosOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9897 (void)_o; 9898 (void)_resolver; 9899 } 9900 9901 inline flatbuffers::Offset<CosOptions> CosOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9902 return CreateCosOptions(_fbb, _o, _rehasher); 9903 } 9904 9905 inline flatbuffers::Offset<CosOptions> CreateCosOptions(flatbuffers::FlatBufferBuilder &_fbb, const CosOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9906 (void)_rehasher; 9907 (void)_o; 9908 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CosOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9909 return tflite::CreateCosOptions( 9910 _fbb); 9911 } 9912 9913 inline ReducerOptionsT *ReducerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9914 auto _o = new ReducerOptionsT(); 9915 UnPackTo(_o, _resolver); 9916 return _o; 9917 } 9918 9919 inline void ReducerOptions::UnPackTo(ReducerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9920 (void)_o; 9921 (void)_resolver; 9922 { auto _e = keep_dims(); _o->keep_dims = _e; }; 9923 } 9924 9925 inline flatbuffers::Offset<ReducerOptions> ReducerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9926 return CreateReducerOptions(_fbb, _o, _rehasher); 9927 } 9928 9929 inline flatbuffers::Offset<ReducerOptions> CreateReducerOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReducerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9930 (void)_rehasher; 9931 (void)_o; 9932 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReducerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9933 auto _keep_dims = _o->keep_dims; 9934 return tflite::CreateReducerOptions( 9935 _fbb, 9936 _keep_dims); 9937 } 9938 9939 inline SqueezeOptionsT *SqueezeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9940 auto _o = new SqueezeOptionsT(); 9941 UnPackTo(_o, _resolver); 9942 return _o; 9943 } 9944 9945 inline void SqueezeOptions::UnPackTo(SqueezeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9946 (void)_o; 9947 (void)_resolver; 9948 { auto _e = squeeze_dims(); if (_e) { _o->squeeze_dims.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->squeeze_dims[_i] = _e->Get(_i); } } }; 9949 } 9950 9951 inline flatbuffers::Offset<SqueezeOptions> SqueezeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9952 return CreateSqueezeOptions(_fbb, _o, _rehasher); 9953 } 9954 9955 inline flatbuffers::Offset<SqueezeOptions> CreateSqueezeOptions(flatbuffers::FlatBufferBuilder &_fbb, const SqueezeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9956 (void)_rehasher; 9957 (void)_o; 9958 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SqueezeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9959 auto _squeeze_dims = _o->squeeze_dims.size() ? _fbb.CreateVector(_o->squeeze_dims) : 0; 9960 return tflite::CreateSqueezeOptions( 9961 _fbb, 9962 _squeeze_dims); 9963 } 9964 9965 inline SplitOptionsT *SplitOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9966 auto _o = new SplitOptionsT(); 9967 UnPackTo(_o, _resolver); 9968 return _o; 9969 } 9970 9971 inline void SplitOptions::UnPackTo(SplitOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9972 (void)_o; 9973 (void)_resolver; 9974 { auto _e = num_splits(); _o->num_splits = _e; }; 9975 } 9976 9977 inline flatbuffers::Offset<SplitOptions> SplitOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 9978 return CreateSplitOptions(_fbb, _o, _rehasher); 9979 } 9980 9981 inline flatbuffers::Offset<SplitOptions> CreateSplitOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 9982 (void)_rehasher; 9983 (void)_o; 9984 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 9985 auto _num_splits = _o->num_splits; 9986 return tflite::CreateSplitOptions( 9987 _fbb, 9988 _num_splits); 9989 } 9990 9991 inline SplitVOptionsT *SplitVOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 9992 auto _o = new SplitVOptionsT(); 9993 UnPackTo(_o, _resolver); 9994 return _o; 9995 } 9996 9997 inline void SplitVOptions::UnPackTo(SplitVOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 9998 (void)_o; 9999 (void)_resolver; 10000 { auto _e = num_splits(); _o->num_splits = _e; }; 10001 } 10002 10003 inline flatbuffers::Offset<SplitVOptions> SplitVOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10004 return CreateSplitVOptions(_fbb, _o, _rehasher); 10005 } 10006 10007 inline flatbuffers::Offset<SplitVOptions> CreateSplitVOptions(flatbuffers::FlatBufferBuilder &_fbb, const SplitVOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10008 (void)_rehasher; 10009 (void)_o; 10010 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SplitVOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10011 auto _num_splits = _o->num_splits; 10012 return tflite::CreateSplitVOptions( 10013 _fbb, 10014 _num_splits); 10015 } 10016 10017 inline StridedSliceOptionsT *StridedSliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10018 auto _o = new StridedSliceOptionsT(); 10019 UnPackTo(_o, _resolver); 10020 return _o; 10021 } 10022 10023 inline void StridedSliceOptions::UnPackTo(StridedSliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10024 (void)_o; 10025 (void)_resolver; 10026 { auto _e = begin_mask(); _o->begin_mask = _e; }; 10027 { auto _e = end_mask(); _o->end_mask = _e; }; 10028 { auto _e = ellipsis_mask(); _o->ellipsis_mask = _e; }; 10029 { auto _e = new_axis_mask(); _o->new_axis_mask = _e; }; 10030 { auto _e = shrink_axis_mask(); _o->shrink_axis_mask = _e; }; 10031 } 10032 10033 inline flatbuffers::Offset<StridedSliceOptions> StridedSliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10034 return CreateStridedSliceOptions(_fbb, _o, _rehasher); 10035 } 10036 10037 inline flatbuffers::Offset<StridedSliceOptions> CreateStridedSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const StridedSliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10038 (void)_rehasher; 10039 (void)_o; 10040 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StridedSliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10041 auto _begin_mask = _o->begin_mask; 10042 auto _end_mask = _o->end_mask; 10043 auto _ellipsis_mask = _o->ellipsis_mask; 10044 auto _new_axis_mask = _o->new_axis_mask; 10045 auto _shrink_axis_mask = _o->shrink_axis_mask; 10046 return tflite::CreateStridedSliceOptions( 10047 _fbb, 10048 _begin_mask, 10049 _end_mask, 10050 _ellipsis_mask, 10051 _new_axis_mask, 10052 _shrink_axis_mask); 10053 } 10054 10055 inline LogSoftmaxOptionsT *LogSoftmaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10056 auto _o = new LogSoftmaxOptionsT(); 10057 UnPackTo(_o, _resolver); 10058 return _o; 10059 } 10060 10061 inline void LogSoftmaxOptions::UnPackTo(LogSoftmaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10062 (void)_o; 10063 (void)_resolver; 10064 } 10065 10066 inline flatbuffers::Offset<LogSoftmaxOptions> LogSoftmaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10067 return CreateLogSoftmaxOptions(_fbb, _o, _rehasher); 10068 } 10069 10070 inline flatbuffers::Offset<LogSoftmaxOptions> CreateLogSoftmaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogSoftmaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10071 (void)_rehasher; 10072 (void)_o; 10073 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogSoftmaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10074 return tflite::CreateLogSoftmaxOptions( 10075 _fbb); 10076 } 10077 10078 inline CastOptionsT *CastOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10079 auto _o = new CastOptionsT(); 10080 UnPackTo(_o, _resolver); 10081 return _o; 10082 } 10083 10084 inline void CastOptions::UnPackTo(CastOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10085 (void)_o; 10086 (void)_resolver; 10087 { auto _e = in_data_type(); _o->in_data_type = _e; }; 10088 { auto _e = out_data_type(); _o->out_data_type = _e; }; 10089 } 10090 10091 inline flatbuffers::Offset<CastOptions> CastOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10092 return CreateCastOptions(_fbb, _o, _rehasher); 10093 } 10094 10095 inline flatbuffers::Offset<CastOptions> CreateCastOptions(flatbuffers::FlatBufferBuilder &_fbb, const CastOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10096 (void)_rehasher; 10097 (void)_o; 10098 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CastOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10099 auto _in_data_type = _o->in_data_type; 10100 auto _out_data_type = _o->out_data_type; 10101 return tflite::CreateCastOptions( 10102 _fbb, 10103 _in_data_type, 10104 _out_data_type); 10105 } 10106 10107 inline DequantizeOptionsT *DequantizeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10108 auto _o = new DequantizeOptionsT(); 10109 UnPackTo(_o, _resolver); 10110 return _o; 10111 } 10112 10113 inline void DequantizeOptions::UnPackTo(DequantizeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10114 (void)_o; 10115 (void)_resolver; 10116 } 10117 10118 inline flatbuffers::Offset<DequantizeOptions> DequantizeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10119 return CreateDequantizeOptions(_fbb, _o, _rehasher); 10120 } 10121 10122 inline flatbuffers::Offset<DequantizeOptions> CreateDequantizeOptions(flatbuffers::FlatBufferBuilder &_fbb, const DequantizeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10123 (void)_rehasher; 10124 (void)_o; 10125 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const DequantizeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10126 return tflite::CreateDequantizeOptions( 10127 _fbb); 10128 } 10129 10130 inline MaximumMinimumOptionsT *MaximumMinimumOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10131 auto _o = new MaximumMinimumOptionsT(); 10132 UnPackTo(_o, _resolver); 10133 return _o; 10134 } 10135 10136 inline void MaximumMinimumOptions::UnPackTo(MaximumMinimumOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10137 (void)_o; 10138 (void)_resolver; 10139 } 10140 10141 inline flatbuffers::Offset<MaximumMinimumOptions> MaximumMinimumOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10142 return CreateMaximumMinimumOptions(_fbb, _o, _rehasher); 10143 } 10144 10145 inline flatbuffers::Offset<MaximumMinimumOptions> CreateMaximumMinimumOptions(flatbuffers::FlatBufferBuilder &_fbb, const MaximumMinimumOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10146 (void)_rehasher; 10147 (void)_o; 10148 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MaximumMinimumOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10149 return tflite::CreateMaximumMinimumOptions( 10150 _fbb); 10151 } 10152 10153 inline TileOptionsT *TileOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10154 auto _o = new TileOptionsT(); 10155 UnPackTo(_o, _resolver); 10156 return _o; 10157 } 10158 10159 inline void TileOptions::UnPackTo(TileOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10160 (void)_o; 10161 (void)_resolver; 10162 } 10163 10164 inline flatbuffers::Offset<TileOptions> TileOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10165 return CreateTileOptions(_fbb, _o, _rehasher); 10166 } 10167 10168 inline flatbuffers::Offset<TileOptions> CreateTileOptions(flatbuffers::FlatBufferBuilder &_fbb, const TileOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10169 (void)_rehasher; 10170 (void)_o; 10171 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TileOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10172 return tflite::CreateTileOptions( 10173 _fbb); 10174 } 10175 10176 inline ArgMaxOptionsT *ArgMaxOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10177 auto _o = new ArgMaxOptionsT(); 10178 UnPackTo(_o, _resolver); 10179 return _o; 10180 } 10181 10182 inline void ArgMaxOptions::UnPackTo(ArgMaxOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10183 (void)_o; 10184 (void)_resolver; 10185 { auto _e = output_type(); _o->output_type = _e; }; 10186 } 10187 10188 inline flatbuffers::Offset<ArgMaxOptions> ArgMaxOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10189 return CreateArgMaxOptions(_fbb, _o, _rehasher); 10190 } 10191 10192 inline flatbuffers::Offset<ArgMaxOptions> CreateArgMaxOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMaxOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10193 (void)_rehasher; 10194 (void)_o; 10195 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMaxOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10196 auto _output_type = _o->output_type; 10197 return tflite::CreateArgMaxOptions( 10198 _fbb, 10199 _output_type); 10200 } 10201 10202 inline ArgMinOptionsT *ArgMinOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10203 auto _o = new ArgMinOptionsT(); 10204 UnPackTo(_o, _resolver); 10205 return _o; 10206 } 10207 10208 inline void ArgMinOptions::UnPackTo(ArgMinOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10209 (void)_o; 10210 (void)_resolver; 10211 { auto _e = output_type(); _o->output_type = _e; }; 10212 } 10213 10214 inline flatbuffers::Offset<ArgMinOptions> ArgMinOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10215 return CreateArgMinOptions(_fbb, _o, _rehasher); 10216 } 10217 10218 inline flatbuffers::Offset<ArgMinOptions> CreateArgMinOptions(flatbuffers::FlatBufferBuilder &_fbb, const ArgMinOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10219 (void)_rehasher; 10220 (void)_o; 10221 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ArgMinOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10222 auto _output_type = _o->output_type; 10223 return tflite::CreateArgMinOptions( 10224 _fbb, 10225 _output_type); 10226 } 10227 10228 inline GreaterOptionsT *GreaterOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10229 auto _o = new GreaterOptionsT(); 10230 UnPackTo(_o, _resolver); 10231 return _o; 10232 } 10233 10234 inline void GreaterOptions::UnPackTo(GreaterOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10235 (void)_o; 10236 (void)_resolver; 10237 } 10238 10239 inline flatbuffers::Offset<GreaterOptions> GreaterOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10240 return CreateGreaterOptions(_fbb, _o, _rehasher); 10241 } 10242 10243 inline flatbuffers::Offset<GreaterOptions> CreateGreaterOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10244 (void)_rehasher; 10245 (void)_o; 10246 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10247 return tflite::CreateGreaterOptions( 10248 _fbb); 10249 } 10250 10251 inline GreaterEqualOptionsT *GreaterEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10252 auto _o = new GreaterEqualOptionsT(); 10253 UnPackTo(_o, _resolver); 10254 return _o; 10255 } 10256 10257 inline void GreaterEqualOptions::UnPackTo(GreaterEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10258 (void)_o; 10259 (void)_resolver; 10260 } 10261 10262 inline flatbuffers::Offset<GreaterEqualOptions> GreaterEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10263 return CreateGreaterEqualOptions(_fbb, _o, _rehasher); 10264 } 10265 10266 inline flatbuffers::Offset<GreaterEqualOptions> CreateGreaterEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const GreaterEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10267 (void)_rehasher; 10268 (void)_o; 10269 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GreaterEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10270 return tflite::CreateGreaterEqualOptions( 10271 _fbb); 10272 } 10273 10274 inline LessOptionsT *LessOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10275 auto _o = new LessOptionsT(); 10276 UnPackTo(_o, _resolver); 10277 return _o; 10278 } 10279 10280 inline void LessOptions::UnPackTo(LessOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10281 (void)_o; 10282 (void)_resolver; 10283 } 10284 10285 inline flatbuffers::Offset<LessOptions> LessOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10286 return CreateLessOptions(_fbb, _o, _rehasher); 10287 } 10288 10289 inline flatbuffers::Offset<LessOptions> CreateLessOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10290 (void)_rehasher; 10291 (void)_o; 10292 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10293 return tflite::CreateLessOptions( 10294 _fbb); 10295 } 10296 10297 inline LessEqualOptionsT *LessEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10298 auto _o = new LessEqualOptionsT(); 10299 UnPackTo(_o, _resolver); 10300 return _o; 10301 } 10302 10303 inline void LessEqualOptions::UnPackTo(LessEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10304 (void)_o; 10305 (void)_resolver; 10306 } 10307 10308 inline flatbuffers::Offset<LessEqualOptions> LessEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10309 return CreateLessEqualOptions(_fbb, _o, _rehasher); 10310 } 10311 10312 inline flatbuffers::Offset<LessEqualOptions> CreateLessEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const LessEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10313 (void)_rehasher; 10314 (void)_o; 10315 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LessEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10316 return tflite::CreateLessEqualOptions( 10317 _fbb); 10318 } 10319 10320 inline NegOptionsT *NegOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10321 auto _o = new NegOptionsT(); 10322 UnPackTo(_o, _resolver); 10323 return _o; 10324 } 10325 10326 inline void NegOptions::UnPackTo(NegOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10327 (void)_o; 10328 (void)_resolver; 10329 } 10330 10331 inline flatbuffers::Offset<NegOptions> NegOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10332 return CreateNegOptions(_fbb, _o, _rehasher); 10333 } 10334 10335 inline flatbuffers::Offset<NegOptions> CreateNegOptions(flatbuffers::FlatBufferBuilder &_fbb, const NegOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10336 (void)_rehasher; 10337 (void)_o; 10338 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NegOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10339 return tflite::CreateNegOptions( 10340 _fbb); 10341 } 10342 10343 inline SelectOptionsT *SelectOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10344 auto _o = new SelectOptionsT(); 10345 UnPackTo(_o, _resolver); 10346 return _o; 10347 } 10348 10349 inline void SelectOptions::UnPackTo(SelectOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10350 (void)_o; 10351 (void)_resolver; 10352 } 10353 10354 inline flatbuffers::Offset<SelectOptions> SelectOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10355 return CreateSelectOptions(_fbb, _o, _rehasher); 10356 } 10357 10358 inline flatbuffers::Offset<SelectOptions> CreateSelectOptions(flatbuffers::FlatBufferBuilder &_fbb, const SelectOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10359 (void)_rehasher; 10360 (void)_o; 10361 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SelectOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10362 return tflite::CreateSelectOptions( 10363 _fbb); 10364 } 10365 10366 inline SliceOptionsT *SliceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10367 auto _o = new SliceOptionsT(); 10368 UnPackTo(_o, _resolver); 10369 return _o; 10370 } 10371 10372 inline void SliceOptions::UnPackTo(SliceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10373 (void)_o; 10374 (void)_resolver; 10375 } 10376 10377 inline flatbuffers::Offset<SliceOptions> SliceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10378 return CreateSliceOptions(_fbb, _o, _rehasher); 10379 } 10380 10381 inline flatbuffers::Offset<SliceOptions> CreateSliceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SliceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10382 (void)_rehasher; 10383 (void)_o; 10384 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SliceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10385 return tflite::CreateSliceOptions( 10386 _fbb); 10387 } 10388 10389 inline TransposeConvOptionsT *TransposeConvOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10390 auto _o = new TransposeConvOptionsT(); 10391 UnPackTo(_o, _resolver); 10392 return _o; 10393 } 10394 10395 inline void TransposeConvOptions::UnPackTo(TransposeConvOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10396 (void)_o; 10397 (void)_resolver; 10398 { auto _e = padding(); _o->padding = _e; }; 10399 { auto _e = stride_w(); _o->stride_w = _e; }; 10400 { auto _e = stride_h(); _o->stride_h = _e; }; 10401 } 10402 10403 inline flatbuffers::Offset<TransposeConvOptions> TransposeConvOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10404 return CreateTransposeConvOptions(_fbb, _o, _rehasher); 10405 } 10406 10407 inline flatbuffers::Offset<TransposeConvOptions> CreateTransposeConvOptions(flatbuffers::FlatBufferBuilder &_fbb, const TransposeConvOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10408 (void)_rehasher; 10409 (void)_o; 10410 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TransposeConvOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10411 auto _padding = _o->padding; 10412 auto _stride_w = _o->stride_w; 10413 auto _stride_h = _o->stride_h; 10414 return tflite::CreateTransposeConvOptions( 10415 _fbb, 10416 _padding, 10417 _stride_w, 10418 _stride_h); 10419 } 10420 10421 inline ExpandDimsOptionsT *ExpandDimsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10422 auto _o = new ExpandDimsOptionsT(); 10423 UnPackTo(_o, _resolver); 10424 return _o; 10425 } 10426 10427 inline void ExpandDimsOptions::UnPackTo(ExpandDimsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10428 (void)_o; 10429 (void)_resolver; 10430 } 10431 10432 inline flatbuffers::Offset<ExpandDimsOptions> ExpandDimsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10433 return CreateExpandDimsOptions(_fbb, _o, _rehasher); 10434 } 10435 10436 inline flatbuffers::Offset<ExpandDimsOptions> CreateExpandDimsOptions(flatbuffers::FlatBufferBuilder &_fbb, const ExpandDimsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10437 (void)_rehasher; 10438 (void)_o; 10439 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExpandDimsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10440 return tflite::CreateExpandDimsOptions( 10441 _fbb); 10442 } 10443 10444 inline SparseToDenseOptionsT *SparseToDenseOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10445 auto _o = new SparseToDenseOptionsT(); 10446 UnPackTo(_o, _resolver); 10447 return _o; 10448 } 10449 10450 inline void SparseToDenseOptions::UnPackTo(SparseToDenseOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10451 (void)_o; 10452 (void)_resolver; 10453 { auto _e = validate_indices(); _o->validate_indices = _e; }; 10454 } 10455 10456 inline flatbuffers::Offset<SparseToDenseOptions> SparseToDenseOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10457 return CreateSparseToDenseOptions(_fbb, _o, _rehasher); 10458 } 10459 10460 inline flatbuffers::Offset<SparseToDenseOptions> CreateSparseToDenseOptions(flatbuffers::FlatBufferBuilder &_fbb, const SparseToDenseOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10461 (void)_rehasher; 10462 (void)_o; 10463 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SparseToDenseOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10464 auto _validate_indices = _o->validate_indices; 10465 return tflite::CreateSparseToDenseOptions( 10466 _fbb, 10467 _validate_indices); 10468 } 10469 10470 inline EqualOptionsT *EqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10471 auto _o = new EqualOptionsT(); 10472 UnPackTo(_o, _resolver); 10473 return _o; 10474 } 10475 10476 inline void EqualOptions::UnPackTo(EqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10477 (void)_o; 10478 (void)_resolver; 10479 } 10480 10481 inline flatbuffers::Offset<EqualOptions> EqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10482 return CreateEqualOptions(_fbb, _o, _rehasher); 10483 } 10484 10485 inline flatbuffers::Offset<EqualOptions> CreateEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const EqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10486 (void)_rehasher; 10487 (void)_o; 10488 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10489 return tflite::CreateEqualOptions( 10490 _fbb); 10491 } 10492 10493 inline NotEqualOptionsT *NotEqualOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10494 auto _o = new NotEqualOptionsT(); 10495 UnPackTo(_o, _resolver); 10496 return _o; 10497 } 10498 10499 inline void NotEqualOptions::UnPackTo(NotEqualOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10500 (void)_o; 10501 (void)_resolver; 10502 } 10503 10504 inline flatbuffers::Offset<NotEqualOptions> NotEqualOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10505 return CreateNotEqualOptions(_fbb, _o, _rehasher); 10506 } 10507 10508 inline flatbuffers::Offset<NotEqualOptions> CreateNotEqualOptions(flatbuffers::FlatBufferBuilder &_fbb, const NotEqualOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10509 (void)_rehasher; 10510 (void)_o; 10511 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NotEqualOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10512 return tflite::CreateNotEqualOptions( 10513 _fbb); 10514 } 10515 10516 inline ShapeOptionsT *ShapeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10517 auto _o = new ShapeOptionsT(); 10518 UnPackTo(_o, _resolver); 10519 return _o; 10520 } 10521 10522 inline void ShapeOptions::UnPackTo(ShapeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10523 (void)_o; 10524 (void)_resolver; 10525 { auto _e = out_type(); _o->out_type = _e; }; 10526 } 10527 10528 inline flatbuffers::Offset<ShapeOptions> ShapeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10529 return CreateShapeOptions(_fbb, _o, _rehasher); 10530 } 10531 10532 inline flatbuffers::Offset<ShapeOptions> CreateShapeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ShapeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10533 (void)_rehasher; 10534 (void)_o; 10535 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShapeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10536 auto _out_type = _o->out_type; 10537 return tflite::CreateShapeOptions( 10538 _fbb, 10539 _out_type); 10540 } 10541 10542 inline RankOptionsT *RankOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10543 auto _o = new RankOptionsT(); 10544 UnPackTo(_o, _resolver); 10545 return _o; 10546 } 10547 10548 inline void RankOptions::UnPackTo(RankOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10549 (void)_o; 10550 (void)_resolver; 10551 } 10552 10553 inline flatbuffers::Offset<RankOptions> RankOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10554 return CreateRankOptions(_fbb, _o, _rehasher); 10555 } 10556 10557 inline flatbuffers::Offset<RankOptions> CreateRankOptions(flatbuffers::FlatBufferBuilder &_fbb, const RankOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10558 (void)_rehasher; 10559 (void)_o; 10560 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RankOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10561 return tflite::CreateRankOptions( 10562 _fbb); 10563 } 10564 10565 inline PowOptionsT *PowOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10566 auto _o = new PowOptionsT(); 10567 UnPackTo(_o, _resolver); 10568 return _o; 10569 } 10570 10571 inline void PowOptions::UnPackTo(PowOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10572 (void)_o; 10573 (void)_resolver; 10574 } 10575 10576 inline flatbuffers::Offset<PowOptions> PowOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10577 return CreatePowOptions(_fbb, _o, _rehasher); 10578 } 10579 10580 inline flatbuffers::Offset<PowOptions> CreatePowOptions(flatbuffers::FlatBufferBuilder &_fbb, const PowOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10581 (void)_rehasher; 10582 (void)_o; 10583 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PowOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10584 return tflite::CreatePowOptions( 10585 _fbb); 10586 } 10587 10588 inline FakeQuantOptionsT *FakeQuantOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10589 auto _o = new FakeQuantOptionsT(); 10590 UnPackTo(_o, _resolver); 10591 return _o; 10592 } 10593 10594 inline void FakeQuantOptions::UnPackTo(FakeQuantOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10595 (void)_o; 10596 (void)_resolver; 10597 { auto _e = min(); _o->min = _e; }; 10598 { auto _e = max(); _o->max = _e; }; 10599 { auto _e = num_bits(); _o->num_bits = _e; }; 10600 { auto _e = narrow_range(); _o->narrow_range = _e; }; 10601 } 10602 10603 inline flatbuffers::Offset<FakeQuantOptions> FakeQuantOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10604 return CreateFakeQuantOptions(_fbb, _o, _rehasher); 10605 } 10606 10607 inline flatbuffers::Offset<FakeQuantOptions> CreateFakeQuantOptions(flatbuffers::FlatBufferBuilder &_fbb, const FakeQuantOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10608 (void)_rehasher; 10609 (void)_o; 10610 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FakeQuantOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10611 auto _min = _o->min; 10612 auto _max = _o->max; 10613 auto _num_bits = _o->num_bits; 10614 auto _narrow_range = _o->narrow_range; 10615 return tflite::CreateFakeQuantOptions( 10616 _fbb, 10617 _min, 10618 _max, 10619 _num_bits, 10620 _narrow_range); 10621 } 10622 10623 inline PackOptionsT *PackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10624 auto _o = new PackOptionsT(); 10625 UnPackTo(_o, _resolver); 10626 return _o; 10627 } 10628 10629 inline void PackOptions::UnPackTo(PackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10630 (void)_o; 10631 (void)_resolver; 10632 { auto _e = values_count(); _o->values_count = _e; }; 10633 { auto _e = axis(); _o->axis = _e; }; 10634 } 10635 10636 inline flatbuffers::Offset<PackOptions> PackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10637 return CreatePackOptions(_fbb, _o, _rehasher); 10638 } 10639 10640 inline flatbuffers::Offset<PackOptions> CreatePackOptions(flatbuffers::FlatBufferBuilder &_fbb, const PackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10641 (void)_rehasher; 10642 (void)_o; 10643 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10644 auto _values_count = _o->values_count; 10645 auto _axis = _o->axis; 10646 return tflite::CreatePackOptions( 10647 _fbb, 10648 _values_count, 10649 _axis); 10650 } 10651 10652 inline LogicalOrOptionsT *LogicalOrOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10653 auto _o = new LogicalOrOptionsT(); 10654 UnPackTo(_o, _resolver); 10655 return _o; 10656 } 10657 10658 inline void LogicalOrOptions::UnPackTo(LogicalOrOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10659 (void)_o; 10660 (void)_resolver; 10661 } 10662 10663 inline flatbuffers::Offset<LogicalOrOptions> LogicalOrOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10664 return CreateLogicalOrOptions(_fbb, _o, _rehasher); 10665 } 10666 10667 inline flatbuffers::Offset<LogicalOrOptions> CreateLogicalOrOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalOrOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10668 (void)_rehasher; 10669 (void)_o; 10670 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalOrOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10671 return tflite::CreateLogicalOrOptions( 10672 _fbb); 10673 } 10674 10675 inline OneHotOptionsT *OneHotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10676 auto _o = new OneHotOptionsT(); 10677 UnPackTo(_o, _resolver); 10678 return _o; 10679 } 10680 10681 inline void OneHotOptions::UnPackTo(OneHotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10682 (void)_o; 10683 (void)_resolver; 10684 { auto _e = axis(); _o->axis = _e; }; 10685 } 10686 10687 inline flatbuffers::Offset<OneHotOptions> OneHotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10688 return CreateOneHotOptions(_fbb, _o, _rehasher); 10689 } 10690 10691 inline flatbuffers::Offset<OneHotOptions> CreateOneHotOptions(flatbuffers::FlatBufferBuilder &_fbb, const OneHotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10692 (void)_rehasher; 10693 (void)_o; 10694 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OneHotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10695 auto _axis = _o->axis; 10696 return tflite::CreateOneHotOptions( 10697 _fbb, 10698 _axis); 10699 } 10700 10701 inline AbsOptionsT *AbsOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10702 auto _o = new AbsOptionsT(); 10703 UnPackTo(_o, _resolver); 10704 return _o; 10705 } 10706 10707 inline void AbsOptions::UnPackTo(AbsOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10708 (void)_o; 10709 (void)_resolver; 10710 } 10711 10712 inline flatbuffers::Offset<AbsOptions> AbsOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10713 return CreateAbsOptions(_fbb, _o, _rehasher); 10714 } 10715 10716 inline flatbuffers::Offset<AbsOptions> CreateAbsOptions(flatbuffers::FlatBufferBuilder &_fbb, const AbsOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10717 (void)_rehasher; 10718 (void)_o; 10719 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AbsOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10720 return tflite::CreateAbsOptions( 10721 _fbb); 10722 } 10723 10724 inline LogicalAndOptionsT *LogicalAndOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10725 auto _o = new LogicalAndOptionsT(); 10726 UnPackTo(_o, _resolver); 10727 return _o; 10728 } 10729 10730 inline void LogicalAndOptions::UnPackTo(LogicalAndOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10731 (void)_o; 10732 (void)_resolver; 10733 } 10734 10735 inline flatbuffers::Offset<LogicalAndOptions> LogicalAndOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10736 return CreateLogicalAndOptions(_fbb, _o, _rehasher); 10737 } 10738 10739 inline flatbuffers::Offset<LogicalAndOptions> CreateLogicalAndOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalAndOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10740 (void)_rehasher; 10741 (void)_o; 10742 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalAndOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10743 return tflite::CreateLogicalAndOptions( 10744 _fbb); 10745 } 10746 10747 inline LogicalNotOptionsT *LogicalNotOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10748 auto _o = new LogicalNotOptionsT(); 10749 UnPackTo(_o, _resolver); 10750 return _o; 10751 } 10752 10753 inline void LogicalNotOptions::UnPackTo(LogicalNotOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10754 (void)_o; 10755 (void)_resolver; 10756 } 10757 10758 inline flatbuffers::Offset<LogicalNotOptions> LogicalNotOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10759 return CreateLogicalNotOptions(_fbb, _o, _rehasher); 10760 } 10761 10762 inline flatbuffers::Offset<LogicalNotOptions> CreateLogicalNotOptions(flatbuffers::FlatBufferBuilder &_fbb, const LogicalNotOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10763 (void)_rehasher; 10764 (void)_o; 10765 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LogicalNotOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10766 return tflite::CreateLogicalNotOptions( 10767 _fbb); 10768 } 10769 10770 inline UnpackOptionsT *UnpackOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10771 auto _o = new UnpackOptionsT(); 10772 UnPackTo(_o, _resolver); 10773 return _o; 10774 } 10775 10776 inline void UnpackOptions::UnPackTo(UnpackOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10777 (void)_o; 10778 (void)_resolver; 10779 { auto _e = num(); _o->num = _e; }; 10780 { auto _e = axis(); _o->axis = _e; }; 10781 } 10782 10783 inline flatbuffers::Offset<UnpackOptions> UnpackOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10784 return CreateUnpackOptions(_fbb, _o, _rehasher); 10785 } 10786 10787 inline flatbuffers::Offset<UnpackOptions> CreateUnpackOptions(flatbuffers::FlatBufferBuilder &_fbb, const UnpackOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10788 (void)_rehasher; 10789 (void)_o; 10790 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UnpackOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10791 auto _num = _o->num; 10792 auto _axis = _o->axis; 10793 return tflite::CreateUnpackOptions( 10794 _fbb, 10795 _num, 10796 _axis); 10797 } 10798 10799 inline FloorDivOptionsT *FloorDivOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10800 auto _o = new FloorDivOptionsT(); 10801 UnPackTo(_o, _resolver); 10802 return _o; 10803 } 10804 10805 inline void FloorDivOptions::UnPackTo(FloorDivOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10806 (void)_o; 10807 (void)_resolver; 10808 } 10809 10810 inline flatbuffers::Offset<FloorDivOptions> FloorDivOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10811 return CreateFloorDivOptions(_fbb, _o, _rehasher); 10812 } 10813 10814 inline flatbuffers::Offset<FloorDivOptions> CreateFloorDivOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorDivOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10815 (void)_rehasher; 10816 (void)_o; 10817 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorDivOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10818 return tflite::CreateFloorDivOptions( 10819 _fbb); 10820 } 10821 10822 inline SquareOptionsT *SquareOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10823 auto _o = new SquareOptionsT(); 10824 UnPackTo(_o, _resolver); 10825 return _o; 10826 } 10827 10828 inline void SquareOptions::UnPackTo(SquareOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10829 (void)_o; 10830 (void)_resolver; 10831 } 10832 10833 inline flatbuffers::Offset<SquareOptions> SquareOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10834 return CreateSquareOptions(_fbb, _o, _rehasher); 10835 } 10836 10837 inline flatbuffers::Offset<SquareOptions> CreateSquareOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquareOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10838 (void)_rehasher; 10839 (void)_o; 10840 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquareOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10841 return tflite::CreateSquareOptions( 10842 _fbb); 10843 } 10844 10845 inline ZerosLikeOptionsT *ZerosLikeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10846 auto _o = new ZerosLikeOptionsT(); 10847 UnPackTo(_o, _resolver); 10848 return _o; 10849 } 10850 10851 inline void ZerosLikeOptions::UnPackTo(ZerosLikeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10852 (void)_o; 10853 (void)_resolver; 10854 } 10855 10856 inline flatbuffers::Offset<ZerosLikeOptions> ZerosLikeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10857 return CreateZerosLikeOptions(_fbb, _o, _rehasher); 10858 } 10859 10860 inline flatbuffers::Offset<ZerosLikeOptions> CreateZerosLikeOptions(flatbuffers::FlatBufferBuilder &_fbb, const ZerosLikeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10861 (void)_rehasher; 10862 (void)_o; 10863 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ZerosLikeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10864 return tflite::CreateZerosLikeOptions( 10865 _fbb); 10866 } 10867 10868 inline FillOptionsT *FillOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10869 auto _o = new FillOptionsT(); 10870 UnPackTo(_o, _resolver); 10871 return _o; 10872 } 10873 10874 inline void FillOptions::UnPackTo(FillOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10875 (void)_o; 10876 (void)_resolver; 10877 } 10878 10879 inline flatbuffers::Offset<FillOptions> FillOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10880 return CreateFillOptions(_fbb, _o, _rehasher); 10881 } 10882 10883 inline flatbuffers::Offset<FillOptions> CreateFillOptions(flatbuffers::FlatBufferBuilder &_fbb, const FillOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10884 (void)_rehasher; 10885 (void)_o; 10886 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FillOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10887 return tflite::CreateFillOptions( 10888 _fbb); 10889 } 10890 10891 inline FloorModOptionsT *FloorModOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10892 auto _o = new FloorModOptionsT(); 10893 UnPackTo(_o, _resolver); 10894 return _o; 10895 } 10896 10897 inline void FloorModOptions::UnPackTo(FloorModOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10898 (void)_o; 10899 (void)_resolver; 10900 } 10901 10902 inline flatbuffers::Offset<FloorModOptions> FloorModOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10903 return CreateFloorModOptions(_fbb, _o, _rehasher); 10904 } 10905 10906 inline flatbuffers::Offset<FloorModOptions> CreateFloorModOptions(flatbuffers::FlatBufferBuilder &_fbb, const FloorModOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10907 (void)_rehasher; 10908 (void)_o; 10909 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloorModOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10910 return tflite::CreateFloorModOptions( 10911 _fbb); 10912 } 10913 10914 inline RangeOptionsT *RangeOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10915 auto _o = new RangeOptionsT(); 10916 UnPackTo(_o, _resolver); 10917 return _o; 10918 } 10919 10920 inline void RangeOptions::UnPackTo(RangeOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10921 (void)_o; 10922 (void)_resolver; 10923 } 10924 10925 inline flatbuffers::Offset<RangeOptions> RangeOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10926 return CreateRangeOptions(_fbb, _o, _rehasher); 10927 } 10928 10929 inline flatbuffers::Offset<RangeOptions> CreateRangeOptions(flatbuffers::FlatBufferBuilder &_fbb, const RangeOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10930 (void)_rehasher; 10931 (void)_o; 10932 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RangeOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10933 return tflite::CreateRangeOptions( 10934 _fbb); 10935 } 10936 10937 inline LeakyReluOptionsT *LeakyReluOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10938 auto _o = new LeakyReluOptionsT(); 10939 UnPackTo(_o, _resolver); 10940 return _o; 10941 } 10942 10943 inline void LeakyReluOptions::UnPackTo(LeakyReluOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10944 (void)_o; 10945 (void)_resolver; 10946 { auto _e = alpha(); _o->alpha = _e; }; 10947 } 10948 10949 inline flatbuffers::Offset<LeakyReluOptions> LeakyReluOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10950 return CreateLeakyReluOptions(_fbb, _o, _rehasher); 10951 } 10952 10953 inline flatbuffers::Offset<LeakyReluOptions> CreateLeakyReluOptions(flatbuffers::FlatBufferBuilder &_fbb, const LeakyReluOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10954 (void)_rehasher; 10955 (void)_o; 10956 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const LeakyReluOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10957 auto _alpha = _o->alpha; 10958 return tflite::CreateLeakyReluOptions( 10959 _fbb, 10960 _alpha); 10961 } 10962 10963 inline SquaredDifferenceOptionsT *SquaredDifferenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10964 auto _o = new SquaredDifferenceOptionsT(); 10965 UnPackTo(_o, _resolver); 10966 return _o; 10967 } 10968 10969 inline void SquaredDifferenceOptions::UnPackTo(SquaredDifferenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10970 (void)_o; 10971 (void)_resolver; 10972 } 10973 10974 inline flatbuffers::Offset<SquaredDifferenceOptions> SquaredDifferenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10975 return CreateSquaredDifferenceOptions(_fbb, _o, _rehasher); 10976 } 10977 10978 inline flatbuffers::Offset<SquaredDifferenceOptions> CreateSquaredDifferenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const SquaredDifferenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 10979 (void)_rehasher; 10980 (void)_o; 10981 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SquaredDifferenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 10982 return tflite::CreateSquaredDifferenceOptions( 10983 _fbb); 10984 } 10985 10986 inline MirrorPadOptionsT *MirrorPadOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 10987 auto _o = new MirrorPadOptionsT(); 10988 UnPackTo(_o, _resolver); 10989 return _o; 10990 } 10991 10992 inline void MirrorPadOptions::UnPackTo(MirrorPadOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 10993 (void)_o; 10994 (void)_resolver; 10995 { auto _e = mode(); _o->mode = _e; }; 10996 } 10997 10998 inline flatbuffers::Offset<MirrorPadOptions> MirrorPadOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 10999 return CreateMirrorPadOptions(_fbb, _o, _rehasher); 11000 } 11001 11002 inline flatbuffers::Offset<MirrorPadOptions> CreateMirrorPadOptions(flatbuffers::FlatBufferBuilder &_fbb, const MirrorPadOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11003 (void)_rehasher; 11004 (void)_o; 11005 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MirrorPadOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11006 auto _mode = _o->mode; 11007 return tflite::CreateMirrorPadOptions( 11008 _fbb, 11009 _mode); 11010 } 11011 11012 inline UniqueOptionsT *UniqueOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11013 auto _o = new UniqueOptionsT(); 11014 UnPackTo(_o, _resolver); 11015 return _o; 11016 } 11017 11018 inline void UniqueOptions::UnPackTo(UniqueOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11019 (void)_o; 11020 (void)_resolver; 11021 { auto _e = idx_out_type(); _o->idx_out_type = _e; }; 11022 } 11023 11024 inline flatbuffers::Offset<UniqueOptions> UniqueOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11025 return CreateUniqueOptions(_fbb, _o, _rehasher); 11026 } 11027 11028 inline flatbuffers::Offset<UniqueOptions> CreateUniqueOptions(flatbuffers::FlatBufferBuilder &_fbb, const UniqueOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11029 (void)_rehasher; 11030 (void)_o; 11031 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const UniqueOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11032 auto _idx_out_type = _o->idx_out_type; 11033 return tflite::CreateUniqueOptions( 11034 _fbb, 11035 _idx_out_type); 11036 } 11037 11038 inline ReverseV2OptionsT *ReverseV2Options::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11039 auto _o = new ReverseV2OptionsT(); 11040 UnPackTo(_o, _resolver); 11041 return _o; 11042 } 11043 11044 inline void ReverseV2Options::UnPackTo(ReverseV2OptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11045 (void)_o; 11046 (void)_resolver; 11047 } 11048 11049 inline flatbuffers::Offset<ReverseV2Options> ReverseV2Options::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11050 return CreateReverseV2Options(_fbb, _o, _rehasher); 11051 } 11052 11053 inline flatbuffers::Offset<ReverseV2Options> CreateReverseV2Options(flatbuffers::FlatBufferBuilder &_fbb, const ReverseV2OptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11054 (void)_rehasher; 11055 (void)_o; 11056 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseV2OptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11057 return tflite::CreateReverseV2Options( 11058 _fbb); 11059 } 11060 11061 inline AddNOptionsT *AddNOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11062 auto _o = new AddNOptionsT(); 11063 UnPackTo(_o, _resolver); 11064 return _o; 11065 } 11066 11067 inline void AddNOptions::UnPackTo(AddNOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11068 (void)_o; 11069 (void)_resolver; 11070 } 11071 11072 inline flatbuffers::Offset<AddNOptions> AddNOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11073 return CreateAddNOptions(_fbb, _o, _rehasher); 11074 } 11075 11076 inline flatbuffers::Offset<AddNOptions> CreateAddNOptions(flatbuffers::FlatBufferBuilder &_fbb, const AddNOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11077 (void)_rehasher; 11078 (void)_o; 11079 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AddNOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11080 return tflite::CreateAddNOptions( 11081 _fbb); 11082 } 11083 11084 inline GatherNdOptionsT *GatherNdOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11085 auto _o = new GatherNdOptionsT(); 11086 UnPackTo(_o, _resolver); 11087 return _o; 11088 } 11089 11090 inline void GatherNdOptions::UnPackTo(GatherNdOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11091 (void)_o; 11092 (void)_resolver; 11093 } 11094 11095 inline flatbuffers::Offset<GatherNdOptions> GatherNdOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11096 return CreateGatherNdOptions(_fbb, _o, _rehasher); 11097 } 11098 11099 inline flatbuffers::Offset<GatherNdOptions> CreateGatherNdOptions(flatbuffers::FlatBufferBuilder &_fbb, const GatherNdOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11100 (void)_rehasher; 11101 (void)_o; 11102 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GatherNdOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11103 return tflite::CreateGatherNdOptions( 11104 _fbb); 11105 } 11106 11107 inline WhereOptionsT *WhereOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11108 auto _o = new WhereOptionsT(); 11109 UnPackTo(_o, _resolver); 11110 return _o; 11111 } 11112 11113 inline void WhereOptions::UnPackTo(WhereOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11114 (void)_o; 11115 (void)_resolver; 11116 } 11117 11118 inline flatbuffers::Offset<WhereOptions> WhereOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11119 return CreateWhereOptions(_fbb, _o, _rehasher); 11120 } 11121 11122 inline flatbuffers::Offset<WhereOptions> CreateWhereOptions(flatbuffers::FlatBufferBuilder &_fbb, const WhereOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11123 (void)_rehasher; 11124 (void)_o; 11125 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const WhereOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11126 return tflite::CreateWhereOptions( 11127 _fbb); 11128 } 11129 11130 inline ReverseSequenceOptionsT *ReverseSequenceOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11131 auto _o = new ReverseSequenceOptionsT(); 11132 UnPackTo(_o, _resolver); 11133 return _o; 11134 } 11135 11136 inline void ReverseSequenceOptions::UnPackTo(ReverseSequenceOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11137 (void)_o; 11138 (void)_resolver; 11139 { auto _e = seq_dim(); _o->seq_dim = _e; }; 11140 { auto _e = batch_dim(); _o->batch_dim = _e; }; 11141 } 11142 11143 inline flatbuffers::Offset<ReverseSequenceOptions> ReverseSequenceOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11144 return CreateReverseSequenceOptions(_fbb, _o, _rehasher); 11145 } 11146 11147 inline flatbuffers::Offset<ReverseSequenceOptions> CreateReverseSequenceOptions(flatbuffers::FlatBufferBuilder &_fbb, const ReverseSequenceOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11148 (void)_rehasher; 11149 (void)_o; 11150 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReverseSequenceOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11151 auto _seq_dim = _o->seq_dim; 11152 auto _batch_dim = _o->batch_dim; 11153 return tflite::CreateReverseSequenceOptions( 11154 _fbb, 11155 _seq_dim, 11156 _batch_dim); 11157 } 11158 11159 inline OperatorCodeT *OperatorCode::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11160 auto _o = new OperatorCodeT(); 11161 UnPackTo(_o, _resolver); 11162 return _o; 11163 } 11164 11165 inline void OperatorCode::UnPackTo(OperatorCodeT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11166 (void)_o; 11167 (void)_resolver; 11168 { auto _e = builtin_code(); _o->builtin_code = _e; }; 11169 { auto _e = custom_code(); if (_e) _o->custom_code = _e->str(); }; 11170 { auto _e = version(); _o->version = _e; }; 11171 } 11172 11173 inline flatbuffers::Offset<OperatorCode> OperatorCode::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11174 return CreateOperatorCode(_fbb, _o, _rehasher); 11175 } 11176 11177 inline flatbuffers::Offset<OperatorCode> CreateOperatorCode(flatbuffers::FlatBufferBuilder &_fbb, const OperatorCodeT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11178 (void)_rehasher; 11179 (void)_o; 11180 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorCodeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11181 auto _builtin_code = _o->builtin_code; 11182 auto _custom_code = _o->custom_code.empty() ? 0 : _fbb.CreateString(_o->custom_code); 11183 auto _version = _o->version; 11184 return tflite::CreateOperatorCode( 11185 _fbb, 11186 _builtin_code, 11187 _custom_code, 11188 _version); 11189 } 11190 11191 inline OperatorT *Operator::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11192 auto _o = new OperatorT(); 11193 UnPackTo(_o, _resolver); 11194 return _o; 11195 } 11196 11197 inline void Operator::UnPackTo(OperatorT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11198 (void)_o; 11199 (void)_resolver; 11200 { auto _e = opcode_index(); _o->opcode_index = _e; }; 11201 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }; 11202 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }; 11203 { auto _e = builtin_options_type(); _o->builtin_options.type = _e; }; 11204 { auto _e = builtin_options(); if (_e) _o->builtin_options.value = BuiltinOptionsUnion::UnPack(_e, builtin_options_type(), _resolver); }; 11205 { auto _e = custom_options(); if (_e) { _o->custom_options.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->custom_options[_i] = _e->Get(_i); } } }; 11206 { auto _e = custom_options_format(); _o->custom_options_format = _e; }; 11207 { auto _e = mutating_variable_inputs(); if (_e) { _o->mutating_variable_inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mutating_variable_inputs[_i] = _e->Get(_i) != 0; } } }; 11208 } 11209 11210 inline flatbuffers::Offset<Operator> Operator::Pack(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11211 return CreateOperator(_fbb, _o, _rehasher); 11212 } 11213 11214 inline flatbuffers::Offset<Operator> CreateOperator(flatbuffers::FlatBufferBuilder &_fbb, const OperatorT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11215 (void)_rehasher; 11216 (void)_o; 11217 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const OperatorT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11218 auto _opcode_index = _o->opcode_index; 11219 auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0; 11220 auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0; 11221 auto _builtin_options_type = _o->builtin_options.type; 11222 auto _builtin_options = _o->builtin_options.Pack(_fbb); 11223 auto _custom_options = _o->custom_options.size() ? _fbb.CreateVector(_o->custom_options) : 0; 11224 auto _custom_options_format = _o->custom_options_format; 11225 auto _mutating_variable_inputs = _o->mutating_variable_inputs.size() ? _fbb.CreateVector(_o->mutating_variable_inputs) : 0; 11226 return tflite::CreateOperator( 11227 _fbb, 11228 _opcode_index, 11229 _inputs, 11230 _outputs, 11231 _builtin_options_type, 11232 _builtin_options, 11233 _custom_options, 11234 _custom_options_format, 11235 _mutating_variable_inputs); 11236 } 11237 11238 inline SubGraphT *SubGraph::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11239 auto _o = new SubGraphT(); 11240 UnPackTo(_o, _resolver); 11241 return _o; 11242 } 11243 11244 inline void SubGraph::UnPackTo(SubGraphT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11245 (void)_o; 11246 (void)_resolver; 11247 { auto _e = tensors(); if (_e) { _o->tensors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tensors[_i] = std::unique_ptr<TensorT>(_e->Get(_i)->UnPack(_resolver)); } } }; 11248 { auto _e = inputs(); if (_e) { _o->inputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->inputs[_i] = _e->Get(_i); } } }; 11249 { auto _e = outputs(); if (_e) { _o->outputs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->outputs[_i] = _e->Get(_i); } } }; 11250 { auto _e = operators(); if (_e) { _o->operators.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operators[_i] = std::unique_ptr<OperatorT>(_e->Get(_i)->UnPack(_resolver)); } } }; 11251 { auto _e = name(); if (_e) _o->name = _e->str(); }; 11252 } 11253 11254 inline flatbuffers::Offset<SubGraph> SubGraph::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11255 return CreateSubGraph(_fbb, _o, _rehasher); 11256 } 11257 11258 inline flatbuffers::Offset<SubGraph> CreateSubGraph(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11259 (void)_rehasher; 11260 (void)_o; 11261 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubGraphT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11262 auto _tensors = _o->tensors.size() ? _fbb.CreateVector<flatbuffers::Offset<Tensor>> (_o->tensors.size(), [](size_t i, _VectorArgs *__va) { return CreateTensor(*__va->__fbb, __va->__o->tensors[i].get(), __va->__rehasher); }, &_va ) : 0; 11263 auto _inputs = _o->inputs.size() ? _fbb.CreateVector(_o->inputs) : 0; 11264 auto _outputs = _o->outputs.size() ? _fbb.CreateVector(_o->outputs) : 0; 11265 auto _operators = _o->operators.size() ? _fbb.CreateVector<flatbuffers::Offset<Operator>> (_o->operators.size(), [](size_t i, _VectorArgs *__va) { return CreateOperator(*__va->__fbb, __va->__o->operators[i].get(), __va->__rehasher); }, &_va ) : 0; 11266 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); 11267 return tflite::CreateSubGraph( 11268 _fbb, 11269 _tensors, 11270 _inputs, 11271 _outputs, 11272 _operators, 11273 _name); 11274 } 11275 11276 inline BufferT *Buffer::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11277 auto _o = new BufferT(); 11278 UnPackTo(_o, _resolver); 11279 return _o; 11280 } 11281 11282 inline void Buffer::UnPackTo(BufferT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11283 (void)_o; 11284 (void)_resolver; 11285 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i); } } }; 11286 } 11287 11288 inline flatbuffers::Offset<Buffer> Buffer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BufferT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11289 return CreateBuffer(_fbb, _o, _rehasher); 11290 } 11291 11292 inline flatbuffers::Offset<Buffer> CreateBuffer(flatbuffers::FlatBufferBuilder &_fbb, const BufferT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11293 (void)_rehasher; 11294 (void)_o; 11295 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BufferT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11296 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; 11297 return tflite::CreateBuffer( 11298 _fbb, 11299 _data); 11300 } 11301 11302 inline ModelT *Model::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 11303 auto _o = new ModelT(); 11304 UnPackTo(_o, _resolver); 11305 return _o; 11306 } 11307 11308 inline void Model::UnPackTo(ModelT *_o, const flatbuffers::resolver_function_t *_resolver) const { 11309 (void)_o; 11310 (void)_resolver; 11311 { auto _e = version(); _o->version = _e; }; 11312 { auto _e = operator_codes(); if (_e) { _o->operator_codes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->operator_codes[_i] = std::unique_ptr<OperatorCodeT>(_e->Get(_i)->UnPack(_resolver)); } } }; 11313 { auto _e = subgraphs(); if (_e) { _o->subgraphs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->subgraphs[_i] = std::unique_ptr<SubGraphT>(_e->Get(_i)->UnPack(_resolver)); } } }; 11314 { auto _e = description(); if (_e) _o->description = _e->str(); }; 11315 { auto _e = buffers(); if (_e) { _o->buffers.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffers[_i] = std::unique_ptr<BufferT>(_e->Get(_i)->UnPack(_resolver)); } } }; 11316 { auto _e = metadata_buffer(); if (_e) { _o->metadata_buffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata_buffer[_i] = _e->Get(_i); } } }; 11317 } 11318 11319 inline flatbuffers::Offset<Model> Model::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 11320 return CreateModel(_fbb, _o, _rehasher); 11321 } 11322 11323 inline flatbuffers::Offset<Model> CreateModel(flatbuffers::FlatBufferBuilder &_fbb, const ModelT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 11324 (void)_rehasher; 11325 (void)_o; 11326 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 11327 auto _version = _o->version; 11328 auto _operator_codes = _o->operator_codes.size() ? _fbb.CreateVector<flatbuffers::Offset<OperatorCode>> (_o->operator_codes.size(), [](size_t i, _VectorArgs *__va) { return CreateOperatorCode(*__va->__fbb, __va->__o->operator_codes[i].get(), __va->__rehasher); }, &_va ) : 0; 11329 auto _subgraphs = _o->subgraphs.size() ? _fbb.CreateVector<flatbuffers::Offset<SubGraph>> (_o->subgraphs.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraph(*__va->__fbb, __va->__o->subgraphs[i].get(), __va->__rehasher); }, &_va ) : 0; 11330 auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description); 11331 auto _buffers = _o->buffers.size() ? _fbb.CreateVector<flatbuffers::Offset<Buffer>> (_o->buffers.size(), [](size_t i, _VectorArgs *__va) { return CreateBuffer(*__va->__fbb, __va->__o->buffers[i].get(), __va->__rehasher); }, &_va ) : 0; 11332 auto _metadata_buffer = _o->metadata_buffer.size() ? _fbb.CreateVector(_o->metadata_buffer) : 0; 11333 return tflite::CreateModel( 11334 _fbb, 11335 _version, 11336 _operator_codes, 11337 _subgraphs, 11338 _description, 11339 _buffers, 11340 _metadata_buffer); 11341 } 11342 11343 inline bool VerifyQuantizationDetails(flatbuffers::Verifier &verifier, const void *obj, QuantizationDetails type) { 11344 switch (type) { 11345 case QuantizationDetails_NONE: { 11346 return true; 11347 } 11348 case QuantizationDetails_CustomQuantization: { 11349 auto ptr = reinterpret_cast<const CustomQuantization *>(obj); 11350 return verifier.VerifyTable(ptr); 11351 } 11352 default: return false; 11353 } 11354 } 11355 11356 inline bool VerifyQuantizationDetailsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 11357 if (!values || !types) return !values && !types; 11358 if (values->size() != types->size()) return false; 11359 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 11360 if (!VerifyQuantizationDetails( 11361 verifier, values->Get(i), types->GetEnum<QuantizationDetails>(i))) { 11362 return false; 11363 } 11364 } 11365 return true; 11366 } 11367 11368 inline void *QuantizationDetailsUnion::UnPack(const void *obj, QuantizationDetails type, const flatbuffers::resolver_function_t *resolver) { 11369 switch (type) { 11370 case QuantizationDetails_CustomQuantization: { 11371 auto ptr = reinterpret_cast<const CustomQuantization *>(obj); 11372 return ptr->UnPack(resolver); 11373 } 11374 default: return nullptr; 11375 } 11376 } 11377 11378 inline flatbuffers::Offset<void> QuantizationDetailsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 11379 switch (type) { 11380 case QuantizationDetails_CustomQuantization: { 11381 auto ptr = reinterpret_cast<const CustomQuantizationT *>(value); 11382 return CreateCustomQuantization(_fbb, ptr, _rehasher).Union(); 11383 } 11384 default: return 0; 11385 } 11386 } 11387 11388 inline QuantizationDetailsUnion::QuantizationDetailsUnion(const QuantizationDetailsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) { 11389 switch (type) { 11390 case QuantizationDetails_CustomQuantization: { 11391 value = new CustomQuantizationT(*reinterpret_cast<CustomQuantizationT *>(u.value)); 11392 break; 11393 } 11394 default: 11395 break; 11396 } 11397 } 11398 11399 inline void QuantizationDetailsUnion::Reset() { 11400 switch (type) { 11401 case QuantizationDetails_CustomQuantization: { 11402 auto ptr = reinterpret_cast<CustomQuantizationT *>(value); 11403 delete ptr; 11404 break; 11405 } 11406 default: break; 11407 } 11408 value = nullptr; 11409 type = QuantizationDetails_NONE; 11410 } 11411 11412 inline bool VerifyBuiltinOptions(flatbuffers::Verifier &verifier, const void *obj, BuiltinOptions type) { 11413 switch (type) { 11414 case BuiltinOptions_NONE: { 11415 return true; 11416 } 11417 case BuiltinOptions_Conv2DOptions: { 11418 auto ptr = reinterpret_cast<const Conv2DOptions *>(obj); 11419 return verifier.VerifyTable(ptr); 11420 } 11421 case BuiltinOptions_DepthwiseConv2DOptions: { 11422 auto ptr = reinterpret_cast<const DepthwiseConv2DOptions *>(obj); 11423 return verifier.VerifyTable(ptr); 11424 } 11425 case BuiltinOptions_ConcatEmbeddingsOptions: { 11426 auto ptr = reinterpret_cast<const ConcatEmbeddingsOptions *>(obj); 11427 return verifier.VerifyTable(ptr); 11428 } 11429 case BuiltinOptions_LSHProjectionOptions: { 11430 auto ptr = reinterpret_cast<const LSHProjectionOptions *>(obj); 11431 return verifier.VerifyTable(ptr); 11432 } 11433 case BuiltinOptions_Pool2DOptions: { 11434 auto ptr = reinterpret_cast<const Pool2DOptions *>(obj); 11435 return verifier.VerifyTable(ptr); 11436 } 11437 case BuiltinOptions_SVDFOptions: { 11438 auto ptr = reinterpret_cast<const SVDFOptions *>(obj); 11439 return verifier.VerifyTable(ptr); 11440 } 11441 case BuiltinOptions_RNNOptions: { 11442 auto ptr = reinterpret_cast<const RNNOptions *>(obj); 11443 return verifier.VerifyTable(ptr); 11444 } 11445 case BuiltinOptions_FullyConnectedOptions: { 11446 auto ptr = reinterpret_cast<const FullyConnectedOptions *>(obj); 11447 return verifier.VerifyTable(ptr); 11448 } 11449 case BuiltinOptions_SoftmaxOptions: { 11450 auto ptr = reinterpret_cast<const SoftmaxOptions *>(obj); 11451 return verifier.VerifyTable(ptr); 11452 } 11453 case BuiltinOptions_ConcatenationOptions: { 11454 auto ptr = reinterpret_cast<const ConcatenationOptions *>(obj); 11455 return verifier.VerifyTable(ptr); 11456 } 11457 case BuiltinOptions_AddOptions: { 11458 auto ptr = reinterpret_cast<const AddOptions *>(obj); 11459 return verifier.VerifyTable(ptr); 11460 } 11461 case BuiltinOptions_L2NormOptions: { 11462 auto ptr = reinterpret_cast<const L2NormOptions *>(obj); 11463 return verifier.VerifyTable(ptr); 11464 } 11465 case BuiltinOptions_LocalResponseNormalizationOptions: { 11466 auto ptr = reinterpret_cast<const LocalResponseNormalizationOptions *>(obj); 11467 return verifier.VerifyTable(ptr); 11468 } 11469 case BuiltinOptions_LSTMOptions: { 11470 auto ptr = reinterpret_cast<const LSTMOptions *>(obj); 11471 return verifier.VerifyTable(ptr); 11472 } 11473 case BuiltinOptions_ResizeBilinearOptions: { 11474 auto ptr = reinterpret_cast<const ResizeBilinearOptions *>(obj); 11475 return verifier.VerifyTable(ptr); 11476 } 11477 case BuiltinOptions_CallOptions: { 11478 auto ptr = reinterpret_cast<const CallOptions *>(obj); 11479 return verifier.VerifyTable(ptr); 11480 } 11481 case BuiltinOptions_ReshapeOptions: { 11482 auto ptr = reinterpret_cast<const ReshapeOptions *>(obj); 11483 return verifier.VerifyTable(ptr); 11484 } 11485 case BuiltinOptions_SkipGramOptions: { 11486 auto ptr = reinterpret_cast<const SkipGramOptions *>(obj); 11487 return verifier.VerifyTable(ptr); 11488 } 11489 case BuiltinOptions_SpaceToDepthOptions: { 11490 auto ptr = reinterpret_cast<const SpaceToDepthOptions *>(obj); 11491 return verifier.VerifyTable(ptr); 11492 } 11493 case BuiltinOptions_EmbeddingLookupSparseOptions: { 11494 auto ptr = reinterpret_cast<const EmbeddingLookupSparseOptions *>(obj); 11495 return verifier.VerifyTable(ptr); 11496 } 11497 case BuiltinOptions_MulOptions: { 11498 auto ptr = reinterpret_cast<const MulOptions *>(obj); 11499 return verifier.VerifyTable(ptr); 11500 } 11501 case BuiltinOptions_PadOptions: { 11502 auto ptr = reinterpret_cast<const PadOptions *>(obj); 11503 return verifier.VerifyTable(ptr); 11504 } 11505 case BuiltinOptions_GatherOptions: { 11506 auto ptr = reinterpret_cast<const GatherOptions *>(obj); 11507 return verifier.VerifyTable(ptr); 11508 } 11509 case BuiltinOptions_BatchToSpaceNDOptions: { 11510 auto ptr = reinterpret_cast<const BatchToSpaceNDOptions *>(obj); 11511 return verifier.VerifyTable(ptr); 11512 } 11513 case BuiltinOptions_SpaceToBatchNDOptions: { 11514 auto ptr = reinterpret_cast<const SpaceToBatchNDOptions *>(obj); 11515 return verifier.VerifyTable(ptr); 11516 } 11517 case BuiltinOptions_TransposeOptions: { 11518 auto ptr = reinterpret_cast<const TransposeOptions *>(obj); 11519 return verifier.VerifyTable(ptr); 11520 } 11521 case BuiltinOptions_ReducerOptions: { 11522 auto ptr = reinterpret_cast<const ReducerOptions *>(obj); 11523 return verifier.VerifyTable(ptr); 11524 } 11525 case BuiltinOptions_SubOptions: { 11526 auto ptr = reinterpret_cast<const SubOptions *>(obj); 11527 return verifier.VerifyTable(ptr); 11528 } 11529 case BuiltinOptions_DivOptions: { 11530 auto ptr = reinterpret_cast<const DivOptions *>(obj); 11531 return verifier.VerifyTable(ptr); 11532 } 11533 case BuiltinOptions_SqueezeOptions: { 11534 auto ptr = reinterpret_cast<const SqueezeOptions *>(obj); 11535 return verifier.VerifyTable(ptr); 11536 } 11537 case BuiltinOptions_SequenceRNNOptions: { 11538 auto ptr = reinterpret_cast<const SequenceRNNOptions *>(obj); 11539 return verifier.VerifyTable(ptr); 11540 } 11541 case BuiltinOptions_StridedSliceOptions: { 11542 auto ptr = reinterpret_cast<const StridedSliceOptions *>(obj); 11543 return verifier.VerifyTable(ptr); 11544 } 11545 case BuiltinOptions_ExpOptions: { 11546 auto ptr = reinterpret_cast<const ExpOptions *>(obj); 11547 return verifier.VerifyTable(ptr); 11548 } 11549 case BuiltinOptions_TopKV2Options: { 11550 auto ptr = reinterpret_cast<const TopKV2Options *>(obj); 11551 return verifier.VerifyTable(ptr); 11552 } 11553 case BuiltinOptions_SplitOptions: { 11554 auto ptr = reinterpret_cast<const SplitOptions *>(obj); 11555 return verifier.VerifyTable(ptr); 11556 } 11557 case BuiltinOptions_LogSoftmaxOptions: { 11558 auto ptr = reinterpret_cast<const LogSoftmaxOptions *>(obj); 11559 return verifier.VerifyTable(ptr); 11560 } 11561 case BuiltinOptions_CastOptions: { 11562 auto ptr = reinterpret_cast<const CastOptions *>(obj); 11563 return verifier.VerifyTable(ptr); 11564 } 11565 case BuiltinOptions_DequantizeOptions: { 11566 auto ptr = reinterpret_cast<const DequantizeOptions *>(obj); 11567 return verifier.VerifyTable(ptr); 11568 } 11569 case BuiltinOptions_MaximumMinimumOptions: { 11570 auto ptr = reinterpret_cast<const MaximumMinimumOptions *>(obj); 11571 return verifier.VerifyTable(ptr); 11572 } 11573 case BuiltinOptions_ArgMaxOptions: { 11574 auto ptr = reinterpret_cast<const ArgMaxOptions *>(obj); 11575 return verifier.VerifyTable(ptr); 11576 } 11577 case BuiltinOptions_LessOptions: { 11578 auto ptr = reinterpret_cast<const LessOptions *>(obj); 11579 return verifier.VerifyTable(ptr); 11580 } 11581 case BuiltinOptions_NegOptions: { 11582 auto ptr = reinterpret_cast<const NegOptions *>(obj); 11583 return verifier.VerifyTable(ptr); 11584 } 11585 case BuiltinOptions_PadV2Options: { 11586 auto ptr = reinterpret_cast<const PadV2Options *>(obj); 11587 return verifier.VerifyTable(ptr); 11588 } 11589 case BuiltinOptions_GreaterOptions: { 11590 auto ptr = reinterpret_cast<const GreaterOptions *>(obj); 11591 return verifier.VerifyTable(ptr); 11592 } 11593 case BuiltinOptions_GreaterEqualOptions: { 11594 auto ptr = reinterpret_cast<const GreaterEqualOptions *>(obj); 11595 return verifier.VerifyTable(ptr); 11596 } 11597 case BuiltinOptions_LessEqualOptions: { 11598 auto ptr = reinterpret_cast<const LessEqualOptions *>(obj); 11599 return verifier.VerifyTable(ptr); 11600 } 11601 case BuiltinOptions_SelectOptions: { 11602 auto ptr = reinterpret_cast<const SelectOptions *>(obj); 11603 return verifier.VerifyTable(ptr); 11604 } 11605 case BuiltinOptions_SliceOptions: { 11606 auto ptr = reinterpret_cast<const SliceOptions *>(obj); 11607 return verifier.VerifyTable(ptr); 11608 } 11609 case BuiltinOptions_TransposeConvOptions: { 11610 auto ptr = reinterpret_cast<const TransposeConvOptions *>(obj); 11611 return verifier.VerifyTable(ptr); 11612 } 11613 case BuiltinOptions_SparseToDenseOptions: { 11614 auto ptr = reinterpret_cast<const SparseToDenseOptions *>(obj); 11615 return verifier.VerifyTable(ptr); 11616 } 11617 case BuiltinOptions_TileOptions: { 11618 auto ptr = reinterpret_cast<const TileOptions *>(obj); 11619 return verifier.VerifyTable(ptr); 11620 } 11621 case BuiltinOptions_ExpandDimsOptions: { 11622 auto ptr = reinterpret_cast<const ExpandDimsOptions *>(obj); 11623 return verifier.VerifyTable(ptr); 11624 } 11625 case BuiltinOptions_EqualOptions: { 11626 auto ptr = reinterpret_cast<const EqualOptions *>(obj); 11627 return verifier.VerifyTable(ptr); 11628 } 11629 case BuiltinOptions_NotEqualOptions: { 11630 auto ptr = reinterpret_cast<const NotEqualOptions *>(obj); 11631 return verifier.VerifyTable(ptr); 11632 } 11633 case BuiltinOptions_ShapeOptions: { 11634 auto ptr = reinterpret_cast<const ShapeOptions *>(obj); 11635 return verifier.VerifyTable(ptr); 11636 } 11637 case BuiltinOptions_PowOptions: { 11638 auto ptr = reinterpret_cast<const PowOptions *>(obj); 11639 return verifier.VerifyTable(ptr); 11640 } 11641 case BuiltinOptions_ArgMinOptions: { 11642 auto ptr = reinterpret_cast<const ArgMinOptions *>(obj); 11643 return verifier.VerifyTable(ptr); 11644 } 11645 case BuiltinOptions_FakeQuantOptions: { 11646 auto ptr = reinterpret_cast<const FakeQuantOptions *>(obj); 11647 return verifier.VerifyTable(ptr); 11648 } 11649 case BuiltinOptions_PackOptions: { 11650 auto ptr = reinterpret_cast<const PackOptions *>(obj); 11651 return verifier.VerifyTable(ptr); 11652 } 11653 case BuiltinOptions_LogicalOrOptions: { 11654 auto ptr = reinterpret_cast<const LogicalOrOptions *>(obj); 11655 return verifier.VerifyTable(ptr); 11656 } 11657 case BuiltinOptions_OneHotOptions: { 11658 auto ptr = reinterpret_cast<const OneHotOptions *>(obj); 11659 return verifier.VerifyTable(ptr); 11660 } 11661 case BuiltinOptions_LogicalAndOptions: { 11662 auto ptr = reinterpret_cast<const LogicalAndOptions *>(obj); 11663 return verifier.VerifyTable(ptr); 11664 } 11665 case BuiltinOptions_LogicalNotOptions: { 11666 auto ptr = reinterpret_cast<const LogicalNotOptions *>(obj); 11667 return verifier.VerifyTable(ptr); 11668 } 11669 case BuiltinOptions_UnpackOptions: { 11670 auto ptr = reinterpret_cast<const UnpackOptions *>(obj); 11671 return verifier.VerifyTable(ptr); 11672 } 11673 case BuiltinOptions_FloorDivOptions: { 11674 auto ptr = reinterpret_cast<const FloorDivOptions *>(obj); 11675 return verifier.VerifyTable(ptr); 11676 } 11677 case BuiltinOptions_SquareOptions: { 11678 auto ptr = reinterpret_cast<const SquareOptions *>(obj); 11679 return verifier.VerifyTable(ptr); 11680 } 11681 case BuiltinOptions_ZerosLikeOptions: { 11682 auto ptr = reinterpret_cast<const ZerosLikeOptions *>(obj); 11683 return verifier.VerifyTable(ptr); 11684 } 11685 case BuiltinOptions_FillOptions: { 11686 auto ptr = reinterpret_cast<const FillOptions *>(obj); 11687 return verifier.VerifyTable(ptr); 11688 } 11689 case BuiltinOptions_BidirectionalSequenceLSTMOptions: { 11690 auto ptr = reinterpret_cast<const BidirectionalSequenceLSTMOptions *>(obj); 11691 return verifier.VerifyTable(ptr); 11692 } 11693 case BuiltinOptions_BidirectionalSequenceRNNOptions: { 11694 auto ptr = reinterpret_cast<const BidirectionalSequenceRNNOptions *>(obj); 11695 return verifier.VerifyTable(ptr); 11696 } 11697 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: { 11698 auto ptr = reinterpret_cast<const UnidirectionalSequenceLSTMOptions *>(obj); 11699 return verifier.VerifyTable(ptr); 11700 } 11701 case BuiltinOptions_FloorModOptions: { 11702 auto ptr = reinterpret_cast<const FloorModOptions *>(obj); 11703 return verifier.VerifyTable(ptr); 11704 } 11705 case BuiltinOptions_RangeOptions: { 11706 auto ptr = reinterpret_cast<const RangeOptions *>(obj); 11707 return verifier.VerifyTable(ptr); 11708 } 11709 case BuiltinOptions_ResizeNearestNeighborOptions: { 11710 auto ptr = reinterpret_cast<const ResizeNearestNeighborOptions *>(obj); 11711 return verifier.VerifyTable(ptr); 11712 } 11713 case BuiltinOptions_LeakyReluOptions: { 11714 auto ptr = reinterpret_cast<const LeakyReluOptions *>(obj); 11715 return verifier.VerifyTable(ptr); 11716 } 11717 case BuiltinOptions_SquaredDifferenceOptions: { 11718 auto ptr = reinterpret_cast<const SquaredDifferenceOptions *>(obj); 11719 return verifier.VerifyTable(ptr); 11720 } 11721 case BuiltinOptions_MirrorPadOptions: { 11722 auto ptr = reinterpret_cast<const MirrorPadOptions *>(obj); 11723 return verifier.VerifyTable(ptr); 11724 } 11725 case BuiltinOptions_AbsOptions: { 11726 auto ptr = reinterpret_cast<const AbsOptions *>(obj); 11727 return verifier.VerifyTable(ptr); 11728 } 11729 case BuiltinOptions_SplitVOptions: { 11730 auto ptr = reinterpret_cast<const SplitVOptions *>(obj); 11731 return verifier.VerifyTable(ptr); 11732 } 11733 case BuiltinOptions_UniqueOptions: { 11734 auto ptr = reinterpret_cast<const UniqueOptions *>(obj); 11735 return verifier.VerifyTable(ptr); 11736 } 11737 case BuiltinOptions_ReverseV2Options: { 11738 auto ptr = reinterpret_cast<const ReverseV2Options *>(obj); 11739 return verifier.VerifyTable(ptr); 11740 } 11741 case BuiltinOptions_AddNOptions: { 11742 auto ptr = reinterpret_cast<const AddNOptions *>(obj); 11743 return verifier.VerifyTable(ptr); 11744 } 11745 case BuiltinOptions_GatherNdOptions: { 11746 auto ptr = reinterpret_cast<const GatherNdOptions *>(obj); 11747 return verifier.VerifyTable(ptr); 11748 } 11749 case BuiltinOptions_CosOptions: { 11750 auto ptr = reinterpret_cast<const CosOptions *>(obj); 11751 return verifier.VerifyTable(ptr); 11752 } 11753 case BuiltinOptions_WhereOptions: { 11754 auto ptr = reinterpret_cast<const WhereOptions *>(obj); 11755 return verifier.VerifyTable(ptr); 11756 } 11757 case BuiltinOptions_RankOptions: { 11758 auto ptr = reinterpret_cast<const RankOptions *>(obj); 11759 return verifier.VerifyTable(ptr); 11760 } 11761 case BuiltinOptions_ReverseSequenceOptions: { 11762 auto ptr = reinterpret_cast<const ReverseSequenceOptions *>(obj); 11763 return verifier.VerifyTable(ptr); 11764 } 11765 default: return false; 11766 } 11767 } 11768 11769 inline bool VerifyBuiltinOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 11770 if (!values || !types) return !values && !types; 11771 if (values->size() != types->size()) return false; 11772 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 11773 if (!VerifyBuiltinOptions( 11774 verifier, values->Get(i), types->GetEnum<BuiltinOptions>(i))) { 11775 return false; 11776 } 11777 } 11778 return true; 11779 } 11780 11781 inline void *BuiltinOptionsUnion::UnPack(const void *obj, BuiltinOptions type, const flatbuffers::resolver_function_t *resolver) { 11782 switch (type) { 11783 case BuiltinOptions_Conv2DOptions: { 11784 auto ptr = reinterpret_cast<const Conv2DOptions *>(obj); 11785 return ptr->UnPack(resolver); 11786 } 11787 case BuiltinOptions_DepthwiseConv2DOptions: { 11788 auto ptr = reinterpret_cast<const DepthwiseConv2DOptions *>(obj); 11789 return ptr->UnPack(resolver); 11790 } 11791 case BuiltinOptions_ConcatEmbeddingsOptions: { 11792 auto ptr = reinterpret_cast<const ConcatEmbeddingsOptions *>(obj); 11793 return ptr->UnPack(resolver); 11794 } 11795 case BuiltinOptions_LSHProjectionOptions: { 11796 auto ptr = reinterpret_cast<const LSHProjectionOptions *>(obj); 11797 return ptr->UnPack(resolver); 11798 } 11799 case BuiltinOptions_Pool2DOptions: { 11800 auto ptr = reinterpret_cast<const Pool2DOptions *>(obj); 11801 return ptr->UnPack(resolver); 11802 } 11803 case BuiltinOptions_SVDFOptions: { 11804 auto ptr = reinterpret_cast<const SVDFOptions *>(obj); 11805 return ptr->UnPack(resolver); 11806 } 11807 case BuiltinOptions_RNNOptions: { 11808 auto ptr = reinterpret_cast<const RNNOptions *>(obj); 11809 return ptr->UnPack(resolver); 11810 } 11811 case BuiltinOptions_FullyConnectedOptions: { 11812 auto ptr = reinterpret_cast<const FullyConnectedOptions *>(obj); 11813 return ptr->UnPack(resolver); 11814 } 11815 case BuiltinOptions_SoftmaxOptions: { 11816 auto ptr = reinterpret_cast<const SoftmaxOptions *>(obj); 11817 return ptr->UnPack(resolver); 11818 } 11819 case BuiltinOptions_ConcatenationOptions: { 11820 auto ptr = reinterpret_cast<const ConcatenationOptions *>(obj); 11821 return ptr->UnPack(resolver); 11822 } 11823 case BuiltinOptions_AddOptions: { 11824 auto ptr = reinterpret_cast<const AddOptions *>(obj); 11825 return ptr->UnPack(resolver); 11826 } 11827 case BuiltinOptions_L2NormOptions: { 11828 auto ptr = reinterpret_cast<const L2NormOptions *>(obj); 11829 return ptr->UnPack(resolver); 11830 } 11831 case BuiltinOptions_LocalResponseNormalizationOptions: { 11832 auto ptr = reinterpret_cast<const LocalResponseNormalizationOptions *>(obj); 11833 return ptr->UnPack(resolver); 11834 } 11835 case BuiltinOptions_LSTMOptions: { 11836 auto ptr = reinterpret_cast<const LSTMOptions *>(obj); 11837 return ptr->UnPack(resolver); 11838 } 11839 case BuiltinOptions_ResizeBilinearOptions: { 11840 auto ptr = reinterpret_cast<const ResizeBilinearOptions *>(obj); 11841 return ptr->UnPack(resolver); 11842 } 11843 case BuiltinOptions_CallOptions: { 11844 auto ptr = reinterpret_cast<const CallOptions *>(obj); 11845 return ptr->UnPack(resolver); 11846 } 11847 case BuiltinOptions_ReshapeOptions: { 11848 auto ptr = reinterpret_cast<const ReshapeOptions *>(obj); 11849 return ptr->UnPack(resolver); 11850 } 11851 case BuiltinOptions_SkipGramOptions: { 11852 auto ptr = reinterpret_cast<const SkipGramOptions *>(obj); 11853 return ptr->UnPack(resolver); 11854 } 11855 case BuiltinOptions_SpaceToDepthOptions: { 11856 auto ptr = reinterpret_cast<const SpaceToDepthOptions *>(obj); 11857 return ptr->UnPack(resolver); 11858 } 11859 case BuiltinOptions_EmbeddingLookupSparseOptions: { 11860 auto ptr = reinterpret_cast<const EmbeddingLookupSparseOptions *>(obj); 11861 return ptr->UnPack(resolver); 11862 } 11863 case BuiltinOptions_MulOptions: { 11864 auto ptr = reinterpret_cast<const MulOptions *>(obj); 11865 return ptr->UnPack(resolver); 11866 } 11867 case BuiltinOptions_PadOptions: { 11868 auto ptr = reinterpret_cast<const PadOptions *>(obj); 11869 return ptr->UnPack(resolver); 11870 } 11871 case BuiltinOptions_GatherOptions: { 11872 auto ptr = reinterpret_cast<const GatherOptions *>(obj); 11873 return ptr->UnPack(resolver); 11874 } 11875 case BuiltinOptions_BatchToSpaceNDOptions: { 11876 auto ptr = reinterpret_cast<const BatchToSpaceNDOptions *>(obj); 11877 return ptr->UnPack(resolver); 11878 } 11879 case BuiltinOptions_SpaceToBatchNDOptions: { 11880 auto ptr = reinterpret_cast<const SpaceToBatchNDOptions *>(obj); 11881 return ptr->UnPack(resolver); 11882 } 11883 case BuiltinOptions_TransposeOptions: { 11884 auto ptr = reinterpret_cast<const TransposeOptions *>(obj); 11885 return ptr->UnPack(resolver); 11886 } 11887 case BuiltinOptions_ReducerOptions: { 11888 auto ptr = reinterpret_cast<const ReducerOptions *>(obj); 11889 return ptr->UnPack(resolver); 11890 } 11891 case BuiltinOptions_SubOptions: { 11892 auto ptr = reinterpret_cast<const SubOptions *>(obj); 11893 return ptr->UnPack(resolver); 11894 } 11895 case BuiltinOptions_DivOptions: { 11896 auto ptr = reinterpret_cast<const DivOptions *>(obj); 11897 return ptr->UnPack(resolver); 11898 } 11899 case BuiltinOptions_SqueezeOptions: { 11900 auto ptr = reinterpret_cast<const SqueezeOptions *>(obj); 11901 return ptr->UnPack(resolver); 11902 } 11903 case BuiltinOptions_SequenceRNNOptions: { 11904 auto ptr = reinterpret_cast<const SequenceRNNOptions *>(obj); 11905 return ptr->UnPack(resolver); 11906 } 11907 case BuiltinOptions_StridedSliceOptions: { 11908 auto ptr = reinterpret_cast<const StridedSliceOptions *>(obj); 11909 return ptr->UnPack(resolver); 11910 } 11911 case BuiltinOptions_ExpOptions: { 11912 auto ptr = reinterpret_cast<const ExpOptions *>(obj); 11913 return ptr->UnPack(resolver); 11914 } 11915 case BuiltinOptions_TopKV2Options: { 11916 auto ptr = reinterpret_cast<const TopKV2Options *>(obj); 11917 return ptr->UnPack(resolver); 11918 } 11919 case BuiltinOptions_SplitOptions: { 11920 auto ptr = reinterpret_cast<const SplitOptions *>(obj); 11921 return ptr->UnPack(resolver); 11922 } 11923 case BuiltinOptions_LogSoftmaxOptions: { 11924 auto ptr = reinterpret_cast<const LogSoftmaxOptions *>(obj); 11925 return ptr->UnPack(resolver); 11926 } 11927 case BuiltinOptions_CastOptions: { 11928 auto ptr = reinterpret_cast<const CastOptions *>(obj); 11929 return ptr->UnPack(resolver); 11930 } 11931 case BuiltinOptions_DequantizeOptions: { 11932 auto ptr = reinterpret_cast<const DequantizeOptions *>(obj); 11933 return ptr->UnPack(resolver); 11934 } 11935 case BuiltinOptions_MaximumMinimumOptions: { 11936 auto ptr = reinterpret_cast<const MaximumMinimumOptions *>(obj); 11937 return ptr->UnPack(resolver); 11938 } 11939 case BuiltinOptions_ArgMaxOptions: { 11940 auto ptr = reinterpret_cast<const ArgMaxOptions *>(obj); 11941 return ptr->UnPack(resolver); 11942 } 11943 case BuiltinOptions_LessOptions: { 11944 auto ptr = reinterpret_cast<const LessOptions *>(obj); 11945 return ptr->UnPack(resolver); 11946 } 11947 case BuiltinOptions_NegOptions: { 11948 auto ptr = reinterpret_cast<const NegOptions *>(obj); 11949 return ptr->UnPack(resolver); 11950 } 11951 case BuiltinOptions_PadV2Options: { 11952 auto ptr = reinterpret_cast<const PadV2Options *>(obj); 11953 return ptr->UnPack(resolver); 11954 } 11955 case BuiltinOptions_GreaterOptions: { 11956 auto ptr = reinterpret_cast<const GreaterOptions *>(obj); 11957 return ptr->UnPack(resolver); 11958 } 11959 case BuiltinOptions_GreaterEqualOptions: { 11960 auto ptr = reinterpret_cast<const GreaterEqualOptions *>(obj); 11961 return ptr->UnPack(resolver); 11962 } 11963 case BuiltinOptions_LessEqualOptions: { 11964 auto ptr = reinterpret_cast<const LessEqualOptions *>(obj); 11965 return ptr->UnPack(resolver); 11966 } 11967 case BuiltinOptions_SelectOptions: { 11968 auto ptr = reinterpret_cast<const SelectOptions *>(obj); 11969 return ptr->UnPack(resolver); 11970 } 11971 case BuiltinOptions_SliceOptions: { 11972 auto ptr = reinterpret_cast<const SliceOptions *>(obj); 11973 return ptr->UnPack(resolver); 11974 } 11975 case BuiltinOptions_TransposeConvOptions: { 11976 auto ptr = reinterpret_cast<const TransposeConvOptions *>(obj); 11977 return ptr->UnPack(resolver); 11978 } 11979 case BuiltinOptions_SparseToDenseOptions: { 11980 auto ptr = reinterpret_cast<const SparseToDenseOptions *>(obj); 11981 return ptr->UnPack(resolver); 11982 } 11983 case BuiltinOptions_TileOptions: { 11984 auto ptr = reinterpret_cast<const TileOptions *>(obj); 11985 return ptr->UnPack(resolver); 11986 } 11987 case BuiltinOptions_ExpandDimsOptions: { 11988 auto ptr = reinterpret_cast<const ExpandDimsOptions *>(obj); 11989 return ptr->UnPack(resolver); 11990 } 11991 case BuiltinOptions_EqualOptions: { 11992 auto ptr = reinterpret_cast<const EqualOptions *>(obj); 11993 return ptr->UnPack(resolver); 11994 } 11995 case BuiltinOptions_NotEqualOptions: { 11996 auto ptr = reinterpret_cast<const NotEqualOptions *>(obj); 11997 return ptr->UnPack(resolver); 11998 } 11999 case BuiltinOptions_ShapeOptions: { 12000 auto ptr = reinterpret_cast<const ShapeOptions *>(obj); 12001 return ptr->UnPack(resolver); 12002 } 12003 case BuiltinOptions_PowOptions: { 12004 auto ptr = reinterpret_cast<const PowOptions *>(obj); 12005 return ptr->UnPack(resolver); 12006 } 12007 case BuiltinOptions_ArgMinOptions: { 12008 auto ptr = reinterpret_cast<const ArgMinOptions *>(obj); 12009 return ptr->UnPack(resolver); 12010 } 12011 case BuiltinOptions_FakeQuantOptions: { 12012 auto ptr = reinterpret_cast<const FakeQuantOptions *>(obj); 12013 return ptr->UnPack(resolver); 12014 } 12015 case BuiltinOptions_PackOptions: { 12016 auto ptr = reinterpret_cast<const PackOptions *>(obj); 12017 return ptr->UnPack(resolver); 12018 } 12019 case BuiltinOptions_LogicalOrOptions: { 12020 auto ptr = reinterpret_cast<const LogicalOrOptions *>(obj); 12021 return ptr->UnPack(resolver); 12022 } 12023 case BuiltinOptions_OneHotOptions: { 12024 auto ptr = reinterpret_cast<const OneHotOptions *>(obj); 12025 return ptr->UnPack(resolver); 12026 } 12027 case BuiltinOptions_LogicalAndOptions: { 12028 auto ptr = reinterpret_cast<const LogicalAndOptions *>(obj); 12029 return ptr->UnPack(resolver); 12030 } 12031 case BuiltinOptions_LogicalNotOptions: { 12032 auto ptr = reinterpret_cast<const LogicalNotOptions *>(obj); 12033 return ptr->UnPack(resolver); 12034 } 12035 case BuiltinOptions_UnpackOptions: { 12036 auto ptr = reinterpret_cast<const UnpackOptions *>(obj); 12037 return ptr->UnPack(resolver); 12038 } 12039 case BuiltinOptions_FloorDivOptions: { 12040 auto ptr = reinterpret_cast<const FloorDivOptions *>(obj); 12041 return ptr->UnPack(resolver); 12042 } 12043 case BuiltinOptions_SquareOptions: { 12044 auto ptr = reinterpret_cast<const SquareOptions *>(obj); 12045 return ptr->UnPack(resolver); 12046 } 12047 case BuiltinOptions_ZerosLikeOptions: { 12048 auto ptr = reinterpret_cast<const ZerosLikeOptions *>(obj); 12049 return ptr->UnPack(resolver); 12050 } 12051 case BuiltinOptions_FillOptions: { 12052 auto ptr = reinterpret_cast<const FillOptions *>(obj); 12053 return ptr->UnPack(resolver); 12054 } 12055 case BuiltinOptions_BidirectionalSequenceLSTMOptions: { 12056 auto ptr = reinterpret_cast<const BidirectionalSequenceLSTMOptions *>(obj); 12057 return ptr->UnPack(resolver); 12058 } 12059 case BuiltinOptions_BidirectionalSequenceRNNOptions: { 12060 auto ptr = reinterpret_cast<const BidirectionalSequenceRNNOptions *>(obj); 12061 return ptr->UnPack(resolver); 12062 } 12063 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: { 12064 auto ptr = reinterpret_cast<const UnidirectionalSequenceLSTMOptions *>(obj); 12065 return ptr->UnPack(resolver); 12066 } 12067 case BuiltinOptions_FloorModOptions: { 12068 auto ptr = reinterpret_cast<const FloorModOptions *>(obj); 12069 return ptr->UnPack(resolver); 12070 } 12071 case BuiltinOptions_RangeOptions: { 12072 auto ptr = reinterpret_cast<const RangeOptions *>(obj); 12073 return ptr->UnPack(resolver); 12074 } 12075 case BuiltinOptions_ResizeNearestNeighborOptions: { 12076 auto ptr = reinterpret_cast<const ResizeNearestNeighborOptions *>(obj); 12077 return ptr->UnPack(resolver); 12078 } 12079 case BuiltinOptions_LeakyReluOptions: { 12080 auto ptr = reinterpret_cast<const LeakyReluOptions *>(obj); 12081 return ptr->UnPack(resolver); 12082 } 12083 case BuiltinOptions_SquaredDifferenceOptions: { 12084 auto ptr = reinterpret_cast<const SquaredDifferenceOptions *>(obj); 12085 return ptr->UnPack(resolver); 12086 } 12087 case BuiltinOptions_MirrorPadOptions: { 12088 auto ptr = reinterpret_cast<const MirrorPadOptions *>(obj); 12089 return ptr->UnPack(resolver); 12090 } 12091 case BuiltinOptions_AbsOptions: { 12092 auto ptr = reinterpret_cast<const AbsOptions *>(obj); 12093 return ptr->UnPack(resolver); 12094 } 12095 case BuiltinOptions_SplitVOptions: { 12096 auto ptr = reinterpret_cast<const SplitVOptions *>(obj); 12097 return ptr->UnPack(resolver); 12098 } 12099 case BuiltinOptions_UniqueOptions: { 12100 auto ptr = reinterpret_cast<const UniqueOptions *>(obj); 12101 return ptr->UnPack(resolver); 12102 } 12103 case BuiltinOptions_ReverseV2Options: { 12104 auto ptr = reinterpret_cast<const ReverseV2Options *>(obj); 12105 return ptr->UnPack(resolver); 12106 } 12107 case BuiltinOptions_AddNOptions: { 12108 auto ptr = reinterpret_cast<const AddNOptions *>(obj); 12109 return ptr->UnPack(resolver); 12110 } 12111 case BuiltinOptions_GatherNdOptions: { 12112 auto ptr = reinterpret_cast<const GatherNdOptions *>(obj); 12113 return ptr->UnPack(resolver); 12114 } 12115 case BuiltinOptions_CosOptions: { 12116 auto ptr = reinterpret_cast<const CosOptions *>(obj); 12117 return ptr->UnPack(resolver); 12118 } 12119 case BuiltinOptions_WhereOptions: { 12120 auto ptr = reinterpret_cast<const WhereOptions *>(obj); 12121 return ptr->UnPack(resolver); 12122 } 12123 case BuiltinOptions_RankOptions: { 12124 auto ptr = reinterpret_cast<const RankOptions *>(obj); 12125 return ptr->UnPack(resolver); 12126 } 12127 case BuiltinOptions_ReverseSequenceOptions: { 12128 auto ptr = reinterpret_cast<const ReverseSequenceOptions *>(obj); 12129 return ptr->UnPack(resolver); 12130 } 12131 default: return nullptr; 12132 } 12133 } 12134 12135 inline flatbuffers::Offset<void> BuiltinOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 12136 switch (type) { 12137 case BuiltinOptions_Conv2DOptions: { 12138 auto ptr = reinterpret_cast<const Conv2DOptionsT *>(value); 12139 return CreateConv2DOptions(_fbb, ptr, _rehasher).Union(); 12140 } 12141 case BuiltinOptions_DepthwiseConv2DOptions: { 12142 auto ptr = reinterpret_cast<const DepthwiseConv2DOptionsT *>(value); 12143 return CreateDepthwiseConv2DOptions(_fbb, ptr, _rehasher).Union(); 12144 } 12145 case BuiltinOptions_ConcatEmbeddingsOptions: { 12146 auto ptr = reinterpret_cast<const ConcatEmbeddingsOptionsT *>(value); 12147 return CreateConcatEmbeddingsOptions(_fbb, ptr, _rehasher).Union(); 12148 } 12149 case BuiltinOptions_LSHProjectionOptions: { 12150 auto ptr = reinterpret_cast<const LSHProjectionOptionsT *>(value); 12151 return CreateLSHProjectionOptions(_fbb, ptr, _rehasher).Union(); 12152 } 12153 case BuiltinOptions_Pool2DOptions: { 12154 auto ptr = reinterpret_cast<const Pool2DOptionsT *>(value); 12155 return CreatePool2DOptions(_fbb, ptr, _rehasher).Union(); 12156 } 12157 case BuiltinOptions_SVDFOptions: { 12158 auto ptr = reinterpret_cast<const SVDFOptionsT *>(value); 12159 return CreateSVDFOptions(_fbb, ptr, _rehasher).Union(); 12160 } 12161 case BuiltinOptions_RNNOptions: { 12162 auto ptr = reinterpret_cast<const RNNOptionsT *>(value); 12163 return CreateRNNOptions(_fbb, ptr, _rehasher).Union(); 12164 } 12165 case BuiltinOptions_FullyConnectedOptions: { 12166 auto ptr = reinterpret_cast<const FullyConnectedOptionsT *>(value); 12167 return CreateFullyConnectedOptions(_fbb, ptr, _rehasher).Union(); 12168 } 12169 case BuiltinOptions_SoftmaxOptions: { 12170 auto ptr = reinterpret_cast<const SoftmaxOptionsT *>(value); 12171 return CreateSoftmaxOptions(_fbb, ptr, _rehasher).Union(); 12172 } 12173 case BuiltinOptions_ConcatenationOptions: { 12174 auto ptr = reinterpret_cast<const ConcatenationOptionsT *>(value); 12175 return CreateConcatenationOptions(_fbb, ptr, _rehasher).Union(); 12176 } 12177 case BuiltinOptions_AddOptions: { 12178 auto ptr = reinterpret_cast<const AddOptionsT *>(value); 12179 return CreateAddOptions(_fbb, ptr, _rehasher).Union(); 12180 } 12181 case BuiltinOptions_L2NormOptions: { 12182 auto ptr = reinterpret_cast<const L2NormOptionsT *>(value); 12183 return CreateL2NormOptions(_fbb, ptr, _rehasher).Union(); 12184 } 12185 case BuiltinOptions_LocalResponseNormalizationOptions: { 12186 auto ptr = reinterpret_cast<const LocalResponseNormalizationOptionsT *>(value); 12187 return CreateLocalResponseNormalizationOptions(_fbb, ptr, _rehasher).Union(); 12188 } 12189 case BuiltinOptions_LSTMOptions: { 12190 auto ptr = reinterpret_cast<const LSTMOptionsT *>(value); 12191 return CreateLSTMOptions(_fbb, ptr, _rehasher).Union(); 12192 } 12193 case BuiltinOptions_ResizeBilinearOptions: { 12194 auto ptr = reinterpret_cast<const ResizeBilinearOptionsT *>(value); 12195 return CreateResizeBilinearOptions(_fbb, ptr, _rehasher).Union(); 12196 } 12197 case BuiltinOptions_CallOptions: { 12198 auto ptr = reinterpret_cast<const CallOptionsT *>(value); 12199 return CreateCallOptions(_fbb, ptr, _rehasher).Union(); 12200 } 12201 case BuiltinOptions_ReshapeOptions: { 12202 auto ptr = reinterpret_cast<const ReshapeOptionsT *>(value); 12203 return CreateReshapeOptions(_fbb, ptr, _rehasher).Union(); 12204 } 12205 case BuiltinOptions_SkipGramOptions: { 12206 auto ptr = reinterpret_cast<const SkipGramOptionsT *>(value); 12207 return CreateSkipGramOptions(_fbb, ptr, _rehasher).Union(); 12208 } 12209 case BuiltinOptions_SpaceToDepthOptions: { 12210 auto ptr = reinterpret_cast<const SpaceToDepthOptionsT *>(value); 12211 return CreateSpaceToDepthOptions(_fbb, ptr, _rehasher).Union(); 12212 } 12213 case BuiltinOptions_EmbeddingLookupSparseOptions: { 12214 auto ptr = reinterpret_cast<const EmbeddingLookupSparseOptionsT *>(value); 12215 return CreateEmbeddingLookupSparseOptions(_fbb, ptr, _rehasher).Union(); 12216 } 12217 case BuiltinOptions_MulOptions: { 12218 auto ptr = reinterpret_cast<const MulOptionsT *>(value); 12219 return CreateMulOptions(_fbb, ptr, _rehasher).Union(); 12220 } 12221 case BuiltinOptions_PadOptions: { 12222 auto ptr = reinterpret_cast<const PadOptionsT *>(value); 12223 return CreatePadOptions(_fbb, ptr, _rehasher).Union(); 12224 } 12225 case BuiltinOptions_GatherOptions: { 12226 auto ptr = reinterpret_cast<const GatherOptionsT *>(value); 12227 return CreateGatherOptions(_fbb, ptr, _rehasher).Union(); 12228 } 12229 case BuiltinOptions_BatchToSpaceNDOptions: { 12230 auto ptr = reinterpret_cast<const BatchToSpaceNDOptionsT *>(value); 12231 return CreateBatchToSpaceNDOptions(_fbb, ptr, _rehasher).Union(); 12232 } 12233 case BuiltinOptions_SpaceToBatchNDOptions: { 12234 auto ptr = reinterpret_cast<const SpaceToBatchNDOptionsT *>(value); 12235 return CreateSpaceToBatchNDOptions(_fbb, ptr, _rehasher).Union(); 12236 } 12237 case BuiltinOptions_TransposeOptions: { 12238 auto ptr = reinterpret_cast<const TransposeOptionsT *>(value); 12239 return CreateTransposeOptions(_fbb, ptr, _rehasher).Union(); 12240 } 12241 case BuiltinOptions_ReducerOptions: { 12242 auto ptr = reinterpret_cast<const ReducerOptionsT *>(value); 12243 return CreateReducerOptions(_fbb, ptr, _rehasher).Union(); 12244 } 12245 case BuiltinOptions_SubOptions: { 12246 auto ptr = reinterpret_cast<const SubOptionsT *>(value); 12247 return CreateSubOptions(_fbb, ptr, _rehasher).Union(); 12248 } 12249 case BuiltinOptions_DivOptions: { 12250 auto ptr = reinterpret_cast<const DivOptionsT *>(value); 12251 return CreateDivOptions(_fbb, ptr, _rehasher).Union(); 12252 } 12253 case BuiltinOptions_SqueezeOptions: { 12254 auto ptr = reinterpret_cast<const SqueezeOptionsT *>(value); 12255 return CreateSqueezeOptions(_fbb, ptr, _rehasher).Union(); 12256 } 12257 case BuiltinOptions_SequenceRNNOptions: { 12258 auto ptr = reinterpret_cast<const SequenceRNNOptionsT *>(value); 12259 return CreateSequenceRNNOptions(_fbb, ptr, _rehasher).Union(); 12260 } 12261 case BuiltinOptions_StridedSliceOptions: { 12262 auto ptr = reinterpret_cast<const StridedSliceOptionsT *>(value); 12263 return CreateStridedSliceOptions(_fbb, ptr, _rehasher).Union(); 12264 } 12265 case BuiltinOptions_ExpOptions: { 12266 auto ptr = reinterpret_cast<const ExpOptionsT *>(value); 12267 return CreateExpOptions(_fbb, ptr, _rehasher).Union(); 12268 } 12269 case BuiltinOptions_TopKV2Options: { 12270 auto ptr = reinterpret_cast<const TopKV2OptionsT *>(value); 12271 return CreateTopKV2Options(_fbb, ptr, _rehasher).Union(); 12272 } 12273 case BuiltinOptions_SplitOptions: { 12274 auto ptr = reinterpret_cast<const SplitOptionsT *>(value); 12275 return CreateSplitOptions(_fbb, ptr, _rehasher).Union(); 12276 } 12277 case BuiltinOptions_LogSoftmaxOptions: { 12278 auto ptr = reinterpret_cast<const LogSoftmaxOptionsT *>(value); 12279 return CreateLogSoftmaxOptions(_fbb, ptr, _rehasher).Union(); 12280 } 12281 case BuiltinOptions_CastOptions: { 12282 auto ptr = reinterpret_cast<const CastOptionsT *>(value); 12283 return CreateCastOptions(_fbb, ptr, _rehasher).Union(); 12284 } 12285 case BuiltinOptions_DequantizeOptions: { 12286 auto ptr = reinterpret_cast<const DequantizeOptionsT *>(value); 12287 return CreateDequantizeOptions(_fbb, ptr, _rehasher).Union(); 12288 } 12289 case BuiltinOptions_MaximumMinimumOptions: { 12290 auto ptr = reinterpret_cast<const MaximumMinimumOptionsT *>(value); 12291 return CreateMaximumMinimumOptions(_fbb, ptr, _rehasher).Union(); 12292 } 12293 case BuiltinOptions_ArgMaxOptions: { 12294 auto ptr = reinterpret_cast<const ArgMaxOptionsT *>(value); 12295 return CreateArgMaxOptions(_fbb, ptr, _rehasher).Union(); 12296 } 12297 case BuiltinOptions_LessOptions: { 12298 auto ptr = reinterpret_cast<const LessOptionsT *>(value); 12299 return CreateLessOptions(_fbb, ptr, _rehasher).Union(); 12300 } 12301 case BuiltinOptions_NegOptions: { 12302 auto ptr = reinterpret_cast<const NegOptionsT *>(value); 12303 return CreateNegOptions(_fbb, ptr, _rehasher).Union(); 12304 } 12305 case BuiltinOptions_PadV2Options: { 12306 auto ptr = reinterpret_cast<const PadV2OptionsT *>(value); 12307 return CreatePadV2Options(_fbb, ptr, _rehasher).Union(); 12308 } 12309 case BuiltinOptions_GreaterOptions: { 12310 auto ptr = reinterpret_cast<const GreaterOptionsT *>(value); 12311 return CreateGreaterOptions(_fbb, ptr, _rehasher).Union(); 12312 } 12313 case BuiltinOptions_GreaterEqualOptions: { 12314 auto ptr = reinterpret_cast<const GreaterEqualOptionsT *>(value); 12315 return CreateGreaterEqualOptions(_fbb, ptr, _rehasher).Union(); 12316 } 12317 case BuiltinOptions_LessEqualOptions: { 12318 auto ptr = reinterpret_cast<const LessEqualOptionsT *>(value); 12319 return CreateLessEqualOptions(_fbb, ptr, _rehasher).Union(); 12320 } 12321 case BuiltinOptions_SelectOptions: { 12322 auto ptr = reinterpret_cast<const SelectOptionsT *>(value); 12323 return CreateSelectOptions(_fbb, ptr, _rehasher).Union(); 12324 } 12325 case BuiltinOptions_SliceOptions: { 12326 auto ptr = reinterpret_cast<const SliceOptionsT *>(value); 12327 return CreateSliceOptions(_fbb, ptr, _rehasher).Union(); 12328 } 12329 case BuiltinOptions_TransposeConvOptions: { 12330 auto ptr = reinterpret_cast<const TransposeConvOptionsT *>(value); 12331 return CreateTransposeConvOptions(_fbb, ptr, _rehasher).Union(); 12332 } 12333 case BuiltinOptions_SparseToDenseOptions: { 12334 auto ptr = reinterpret_cast<const SparseToDenseOptionsT *>(value); 12335 return CreateSparseToDenseOptions(_fbb, ptr, _rehasher).Union(); 12336 } 12337 case BuiltinOptions_TileOptions: { 12338 auto ptr = reinterpret_cast<const TileOptionsT *>(value); 12339 return CreateTileOptions(_fbb, ptr, _rehasher).Union(); 12340 } 12341 case BuiltinOptions_ExpandDimsOptions: { 12342 auto ptr = reinterpret_cast<const ExpandDimsOptionsT *>(value); 12343 return CreateExpandDimsOptions(_fbb, ptr, _rehasher).Union(); 12344 } 12345 case BuiltinOptions_EqualOptions: { 12346 auto ptr = reinterpret_cast<const EqualOptionsT *>(value); 12347 return CreateEqualOptions(_fbb, ptr, _rehasher).Union(); 12348 } 12349 case BuiltinOptions_NotEqualOptions: { 12350 auto ptr = reinterpret_cast<const NotEqualOptionsT *>(value); 12351 return CreateNotEqualOptions(_fbb, ptr, _rehasher).Union(); 12352 } 12353 case BuiltinOptions_ShapeOptions: { 12354 auto ptr = reinterpret_cast<const ShapeOptionsT *>(value); 12355 return CreateShapeOptions(_fbb, ptr, _rehasher).Union(); 12356 } 12357 case BuiltinOptions_PowOptions: { 12358 auto ptr = reinterpret_cast<const PowOptionsT *>(value); 12359 return CreatePowOptions(_fbb, ptr, _rehasher).Union(); 12360 } 12361 case BuiltinOptions_ArgMinOptions: { 12362 auto ptr = reinterpret_cast<const ArgMinOptionsT *>(value); 12363 return CreateArgMinOptions(_fbb, ptr, _rehasher).Union(); 12364 } 12365 case BuiltinOptions_FakeQuantOptions: { 12366 auto ptr = reinterpret_cast<const FakeQuantOptionsT *>(value); 12367 return CreateFakeQuantOptions(_fbb, ptr, _rehasher).Union(); 12368 } 12369 case BuiltinOptions_PackOptions: { 12370 auto ptr = reinterpret_cast<const PackOptionsT *>(value); 12371 return CreatePackOptions(_fbb, ptr, _rehasher).Union(); 12372 } 12373 case BuiltinOptions_LogicalOrOptions: { 12374 auto ptr = reinterpret_cast<const LogicalOrOptionsT *>(value); 12375 return CreateLogicalOrOptions(_fbb, ptr, _rehasher).Union(); 12376 } 12377 case BuiltinOptions_OneHotOptions: { 12378 auto ptr = reinterpret_cast<const OneHotOptionsT *>(value); 12379 return CreateOneHotOptions(_fbb, ptr, _rehasher).Union(); 12380 } 12381 case BuiltinOptions_LogicalAndOptions: { 12382 auto ptr = reinterpret_cast<const LogicalAndOptionsT *>(value); 12383 return CreateLogicalAndOptions(_fbb, ptr, _rehasher).Union(); 12384 } 12385 case BuiltinOptions_LogicalNotOptions: { 12386 auto ptr = reinterpret_cast<const LogicalNotOptionsT *>(value); 12387 return CreateLogicalNotOptions(_fbb, ptr, _rehasher).Union(); 12388 } 12389 case BuiltinOptions_UnpackOptions: { 12390 auto ptr = reinterpret_cast<const UnpackOptionsT *>(value); 12391 return CreateUnpackOptions(_fbb, ptr, _rehasher).Union(); 12392 } 12393 case BuiltinOptions_FloorDivOptions: { 12394 auto ptr = reinterpret_cast<const FloorDivOptionsT *>(value); 12395 return CreateFloorDivOptions(_fbb, ptr, _rehasher).Union(); 12396 } 12397 case BuiltinOptions_SquareOptions: { 12398 auto ptr = reinterpret_cast<const SquareOptionsT *>(value); 12399 return CreateSquareOptions(_fbb, ptr, _rehasher).Union(); 12400 } 12401 case BuiltinOptions_ZerosLikeOptions: { 12402 auto ptr = reinterpret_cast<const ZerosLikeOptionsT *>(value); 12403 return CreateZerosLikeOptions(_fbb, ptr, _rehasher).Union(); 12404 } 12405 case BuiltinOptions_FillOptions: { 12406 auto ptr = reinterpret_cast<const FillOptionsT *>(value); 12407 return CreateFillOptions(_fbb, ptr, _rehasher).Union(); 12408 } 12409 case BuiltinOptions_BidirectionalSequenceLSTMOptions: { 12410 auto ptr = reinterpret_cast<const BidirectionalSequenceLSTMOptionsT *>(value); 12411 return CreateBidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union(); 12412 } 12413 case BuiltinOptions_BidirectionalSequenceRNNOptions: { 12414 auto ptr = reinterpret_cast<const BidirectionalSequenceRNNOptionsT *>(value); 12415 return CreateBidirectionalSequenceRNNOptions(_fbb, ptr, _rehasher).Union(); 12416 } 12417 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: { 12418 auto ptr = reinterpret_cast<const UnidirectionalSequenceLSTMOptionsT *>(value); 12419 return CreateUnidirectionalSequenceLSTMOptions(_fbb, ptr, _rehasher).Union(); 12420 } 12421 case BuiltinOptions_FloorModOptions: { 12422 auto ptr = reinterpret_cast<const FloorModOptionsT *>(value); 12423 return CreateFloorModOptions(_fbb, ptr, _rehasher).Union(); 12424 } 12425 case BuiltinOptions_RangeOptions: { 12426 auto ptr = reinterpret_cast<const RangeOptionsT *>(value); 12427 return CreateRangeOptions(_fbb, ptr, _rehasher).Union(); 12428 } 12429 case BuiltinOptions_ResizeNearestNeighborOptions: { 12430 auto ptr = reinterpret_cast<const ResizeNearestNeighborOptionsT *>(value); 12431 return CreateResizeNearestNeighborOptions(_fbb, ptr, _rehasher).Union(); 12432 } 12433 case BuiltinOptions_LeakyReluOptions: { 12434 auto ptr = reinterpret_cast<const LeakyReluOptionsT *>(value); 12435 return CreateLeakyReluOptions(_fbb, ptr, _rehasher).Union(); 12436 } 12437 case BuiltinOptions_SquaredDifferenceOptions: { 12438 auto ptr = reinterpret_cast<const SquaredDifferenceOptionsT *>(value); 12439 return CreateSquaredDifferenceOptions(_fbb, ptr, _rehasher).Union(); 12440 } 12441 case BuiltinOptions_MirrorPadOptions: { 12442 auto ptr = reinterpret_cast<const MirrorPadOptionsT *>(value); 12443 return CreateMirrorPadOptions(_fbb, ptr, _rehasher).Union(); 12444 } 12445 case BuiltinOptions_AbsOptions: { 12446 auto ptr = reinterpret_cast<const AbsOptionsT *>(value); 12447 return CreateAbsOptions(_fbb, ptr, _rehasher).Union(); 12448 } 12449 case BuiltinOptions_SplitVOptions: { 12450 auto ptr = reinterpret_cast<const SplitVOptionsT *>(value); 12451 return CreateSplitVOptions(_fbb, ptr, _rehasher).Union(); 12452 } 12453 case BuiltinOptions_UniqueOptions: { 12454 auto ptr = reinterpret_cast<const UniqueOptionsT *>(value); 12455 return CreateUniqueOptions(_fbb, ptr, _rehasher).Union(); 12456 } 12457 case BuiltinOptions_ReverseV2Options: { 12458 auto ptr = reinterpret_cast<const ReverseV2OptionsT *>(value); 12459 return CreateReverseV2Options(_fbb, ptr, _rehasher).Union(); 12460 } 12461 case BuiltinOptions_AddNOptions: { 12462 auto ptr = reinterpret_cast<const AddNOptionsT *>(value); 12463 return CreateAddNOptions(_fbb, ptr, _rehasher).Union(); 12464 } 12465 case BuiltinOptions_GatherNdOptions: { 12466 auto ptr = reinterpret_cast<const GatherNdOptionsT *>(value); 12467 return CreateGatherNdOptions(_fbb, ptr, _rehasher).Union(); 12468 } 12469 case BuiltinOptions_CosOptions: { 12470 auto ptr = reinterpret_cast<const CosOptionsT *>(value); 12471 return CreateCosOptions(_fbb, ptr, _rehasher).Union(); 12472 } 12473 case BuiltinOptions_WhereOptions: { 12474 auto ptr = reinterpret_cast<const WhereOptionsT *>(value); 12475 return CreateWhereOptions(_fbb, ptr, _rehasher).Union(); 12476 } 12477 case BuiltinOptions_RankOptions: { 12478 auto ptr = reinterpret_cast<const RankOptionsT *>(value); 12479 return CreateRankOptions(_fbb, ptr, _rehasher).Union(); 12480 } 12481 case BuiltinOptions_ReverseSequenceOptions: { 12482 auto ptr = reinterpret_cast<const ReverseSequenceOptionsT *>(value); 12483 return CreateReverseSequenceOptions(_fbb, ptr, _rehasher).Union(); 12484 } 12485 default: return 0; 12486 } 12487 } 12488 12489 inline BuiltinOptionsUnion::BuiltinOptionsUnion(const BuiltinOptionsUnion &u) FLATBUFFERS_NOEXCEPT : type(u.type), value(nullptr) { 12490 switch (type) { 12491 case BuiltinOptions_Conv2DOptions: { 12492 value = new Conv2DOptionsT(*reinterpret_cast<Conv2DOptionsT *>(u.value)); 12493 break; 12494 } 12495 case BuiltinOptions_DepthwiseConv2DOptions: { 12496 value = new DepthwiseConv2DOptionsT(*reinterpret_cast<DepthwiseConv2DOptionsT *>(u.value)); 12497 break; 12498 } 12499 case BuiltinOptions_ConcatEmbeddingsOptions: { 12500 value = new ConcatEmbeddingsOptionsT(*reinterpret_cast<ConcatEmbeddingsOptionsT *>(u.value)); 12501 break; 12502 } 12503 case BuiltinOptions_LSHProjectionOptions: { 12504 value = new LSHProjectionOptionsT(*reinterpret_cast<LSHProjectionOptionsT *>(u.value)); 12505 break; 12506 } 12507 case BuiltinOptions_Pool2DOptions: { 12508 value = new Pool2DOptionsT(*reinterpret_cast<Pool2DOptionsT *>(u.value)); 12509 break; 12510 } 12511 case BuiltinOptions_SVDFOptions: { 12512 value = new SVDFOptionsT(*reinterpret_cast<SVDFOptionsT *>(u.value)); 12513 break; 12514 } 12515 case BuiltinOptions_RNNOptions: { 12516 value = new RNNOptionsT(*reinterpret_cast<RNNOptionsT *>(u.value)); 12517 break; 12518 } 12519 case BuiltinOptions_FullyConnectedOptions: { 12520 value = new FullyConnectedOptionsT(*reinterpret_cast<FullyConnectedOptionsT *>(u.value)); 12521 break; 12522 } 12523 case BuiltinOptions_SoftmaxOptions: { 12524 value = new SoftmaxOptionsT(*reinterpret_cast<SoftmaxOptionsT *>(u.value)); 12525 break; 12526 } 12527 case BuiltinOptions_ConcatenationOptions: { 12528 value = new ConcatenationOptionsT(*reinterpret_cast<ConcatenationOptionsT *>(u.value)); 12529 break; 12530 } 12531 case BuiltinOptions_AddOptions: { 12532 value = new AddOptionsT(*reinterpret_cast<AddOptionsT *>(u.value)); 12533 break; 12534 } 12535 case BuiltinOptions_L2NormOptions: { 12536 value = new L2NormOptionsT(*reinterpret_cast<L2NormOptionsT *>(u.value)); 12537 break; 12538 } 12539 case BuiltinOptions_LocalResponseNormalizationOptions: { 12540 value = new LocalResponseNormalizationOptionsT(*reinterpret_cast<LocalResponseNormalizationOptionsT *>(u.value)); 12541 break; 12542 } 12543 case BuiltinOptions_LSTMOptions: { 12544 value = new LSTMOptionsT(*reinterpret_cast<LSTMOptionsT *>(u.value)); 12545 break; 12546 } 12547 case BuiltinOptions_ResizeBilinearOptions: { 12548 value = new ResizeBilinearOptionsT(*reinterpret_cast<ResizeBilinearOptionsT *>(u.value)); 12549 break; 12550 } 12551 case BuiltinOptions_CallOptions: { 12552 value = new CallOptionsT(*reinterpret_cast<CallOptionsT *>(u.value)); 12553 break; 12554 } 12555 case BuiltinOptions_ReshapeOptions: { 12556 value = new ReshapeOptionsT(*reinterpret_cast<ReshapeOptionsT *>(u.value)); 12557 break; 12558 } 12559 case BuiltinOptions_SkipGramOptions: { 12560 value = new SkipGramOptionsT(*reinterpret_cast<SkipGramOptionsT *>(u.value)); 12561 break; 12562 } 12563 case BuiltinOptions_SpaceToDepthOptions: { 12564 value = new SpaceToDepthOptionsT(*reinterpret_cast<SpaceToDepthOptionsT *>(u.value)); 12565 break; 12566 } 12567 case BuiltinOptions_EmbeddingLookupSparseOptions: { 12568 value = new EmbeddingLookupSparseOptionsT(*reinterpret_cast<EmbeddingLookupSparseOptionsT *>(u.value)); 12569 break; 12570 } 12571 case BuiltinOptions_MulOptions: { 12572 value = new MulOptionsT(*reinterpret_cast<MulOptionsT *>(u.value)); 12573 break; 12574 } 12575 case BuiltinOptions_PadOptions: { 12576 value = new PadOptionsT(*reinterpret_cast<PadOptionsT *>(u.value)); 12577 break; 12578 } 12579 case BuiltinOptions_GatherOptions: { 12580 value = new GatherOptionsT(*reinterpret_cast<GatherOptionsT *>(u.value)); 12581 break; 12582 } 12583 case BuiltinOptions_BatchToSpaceNDOptions: { 12584 value = new BatchToSpaceNDOptionsT(*reinterpret_cast<BatchToSpaceNDOptionsT *>(u.value)); 12585 break; 12586 } 12587 case BuiltinOptions_SpaceToBatchNDOptions: { 12588 value = new SpaceToBatchNDOptionsT(*reinterpret_cast<SpaceToBatchNDOptionsT *>(u.value)); 12589 break; 12590 } 12591 case BuiltinOptions_TransposeOptions: { 12592 value = new TransposeOptionsT(*reinterpret_cast<TransposeOptionsT *>(u.value)); 12593 break; 12594 } 12595 case BuiltinOptions_ReducerOptions: { 12596 value = new ReducerOptionsT(*reinterpret_cast<ReducerOptionsT *>(u.value)); 12597 break; 12598 } 12599 case BuiltinOptions_SubOptions: { 12600 value = new SubOptionsT(*reinterpret_cast<SubOptionsT *>(u.value)); 12601 break; 12602 } 12603 case BuiltinOptions_DivOptions: { 12604 value = new DivOptionsT(*reinterpret_cast<DivOptionsT *>(u.value)); 12605 break; 12606 } 12607 case BuiltinOptions_SqueezeOptions: { 12608 value = new SqueezeOptionsT(*reinterpret_cast<SqueezeOptionsT *>(u.value)); 12609 break; 12610 } 12611 case BuiltinOptions_SequenceRNNOptions: { 12612 value = new SequenceRNNOptionsT(*reinterpret_cast<SequenceRNNOptionsT *>(u.value)); 12613 break; 12614 } 12615 case BuiltinOptions_StridedSliceOptions: { 12616 value = new StridedSliceOptionsT(*reinterpret_cast<StridedSliceOptionsT *>(u.value)); 12617 break; 12618 } 12619 case BuiltinOptions_ExpOptions: { 12620 value = new ExpOptionsT(*reinterpret_cast<ExpOptionsT *>(u.value)); 12621 break; 12622 } 12623 case BuiltinOptions_TopKV2Options: { 12624 value = new TopKV2OptionsT(*reinterpret_cast<TopKV2OptionsT *>(u.value)); 12625 break; 12626 } 12627 case BuiltinOptions_SplitOptions: { 12628 value = new SplitOptionsT(*reinterpret_cast<SplitOptionsT *>(u.value)); 12629 break; 12630 } 12631 case BuiltinOptions_LogSoftmaxOptions: { 12632 value = new LogSoftmaxOptionsT(*reinterpret_cast<LogSoftmaxOptionsT *>(u.value)); 12633 break; 12634 } 12635 case BuiltinOptions_CastOptions: { 12636 value = new CastOptionsT(*reinterpret_cast<CastOptionsT *>(u.value)); 12637 break; 12638 } 12639 case BuiltinOptions_DequantizeOptions: { 12640 value = new DequantizeOptionsT(*reinterpret_cast<DequantizeOptionsT *>(u.value)); 12641 break; 12642 } 12643 case BuiltinOptions_MaximumMinimumOptions: { 12644 value = new MaximumMinimumOptionsT(*reinterpret_cast<MaximumMinimumOptionsT *>(u.value)); 12645 break; 12646 } 12647 case BuiltinOptions_ArgMaxOptions: { 12648 value = new ArgMaxOptionsT(*reinterpret_cast<ArgMaxOptionsT *>(u.value)); 12649 break; 12650 } 12651 case BuiltinOptions_LessOptions: { 12652 value = new LessOptionsT(*reinterpret_cast<LessOptionsT *>(u.value)); 12653 break; 12654 } 12655 case BuiltinOptions_NegOptions: { 12656 value = new NegOptionsT(*reinterpret_cast<NegOptionsT *>(u.value)); 12657 break; 12658 } 12659 case BuiltinOptions_PadV2Options: { 12660 value = new PadV2OptionsT(*reinterpret_cast<PadV2OptionsT *>(u.value)); 12661 break; 12662 } 12663 case BuiltinOptions_GreaterOptions: { 12664 value = new GreaterOptionsT(*reinterpret_cast<GreaterOptionsT *>(u.value)); 12665 break; 12666 } 12667 case BuiltinOptions_GreaterEqualOptions: { 12668 value = new GreaterEqualOptionsT(*reinterpret_cast<GreaterEqualOptionsT *>(u.value)); 12669 break; 12670 } 12671 case BuiltinOptions_LessEqualOptions: { 12672 value = new LessEqualOptionsT(*reinterpret_cast<LessEqualOptionsT *>(u.value)); 12673 break; 12674 } 12675 case BuiltinOptions_SelectOptions: { 12676 value = new SelectOptionsT(*reinterpret_cast<SelectOptionsT *>(u.value)); 12677 break; 12678 } 12679 case BuiltinOptions_SliceOptions: { 12680 value = new SliceOptionsT(*reinterpret_cast<SliceOptionsT *>(u.value)); 12681 break; 12682 } 12683 case BuiltinOptions_TransposeConvOptions: { 12684 value = new TransposeConvOptionsT(*reinterpret_cast<TransposeConvOptionsT *>(u.value)); 12685 break; 12686 } 12687 case BuiltinOptions_SparseToDenseOptions: { 12688 value = new SparseToDenseOptionsT(*reinterpret_cast<SparseToDenseOptionsT *>(u.value)); 12689 break; 12690 } 12691 case BuiltinOptions_TileOptions: { 12692 value = new TileOptionsT(*reinterpret_cast<TileOptionsT *>(u.value)); 12693 break; 12694 } 12695 case BuiltinOptions_ExpandDimsOptions: { 12696 value = new ExpandDimsOptionsT(*reinterpret_cast<ExpandDimsOptionsT *>(u.value)); 12697 break; 12698 } 12699 case BuiltinOptions_EqualOptions: { 12700 value = new EqualOptionsT(*reinterpret_cast<EqualOptionsT *>(u.value)); 12701 break; 12702 } 12703 case BuiltinOptions_NotEqualOptions: { 12704 value = new NotEqualOptionsT(*reinterpret_cast<NotEqualOptionsT *>(u.value)); 12705 break; 12706 } 12707 case BuiltinOptions_ShapeOptions: { 12708 value = new ShapeOptionsT(*reinterpret_cast<ShapeOptionsT *>(u.value)); 12709 break; 12710 } 12711 case BuiltinOptions_PowOptions: { 12712 value = new PowOptionsT(*reinterpret_cast<PowOptionsT *>(u.value)); 12713 break; 12714 } 12715 case BuiltinOptions_ArgMinOptions: { 12716 value = new ArgMinOptionsT(*reinterpret_cast<ArgMinOptionsT *>(u.value)); 12717 break; 12718 } 12719 case BuiltinOptions_FakeQuantOptions: { 12720 value = new FakeQuantOptionsT(*reinterpret_cast<FakeQuantOptionsT *>(u.value)); 12721 break; 12722 } 12723 case BuiltinOptions_PackOptions: { 12724 value = new PackOptionsT(*reinterpret_cast<PackOptionsT *>(u.value)); 12725 break; 12726 } 12727 case BuiltinOptions_LogicalOrOptions: { 12728 value = new LogicalOrOptionsT(*reinterpret_cast<LogicalOrOptionsT *>(u.value)); 12729 break; 12730 } 12731 case BuiltinOptions_OneHotOptions: { 12732 value = new OneHotOptionsT(*reinterpret_cast<OneHotOptionsT *>(u.value)); 12733 break; 12734 } 12735 case BuiltinOptions_LogicalAndOptions: { 12736 value = new LogicalAndOptionsT(*reinterpret_cast<LogicalAndOptionsT *>(u.value)); 12737 break; 12738 } 12739 case BuiltinOptions_LogicalNotOptions: { 12740 value = new LogicalNotOptionsT(*reinterpret_cast<LogicalNotOptionsT *>(u.value)); 12741 break; 12742 } 12743 case BuiltinOptions_UnpackOptions: { 12744 value = new UnpackOptionsT(*reinterpret_cast<UnpackOptionsT *>(u.value)); 12745 break; 12746 } 12747 case BuiltinOptions_FloorDivOptions: { 12748 value = new FloorDivOptionsT(*reinterpret_cast<FloorDivOptionsT *>(u.value)); 12749 break; 12750 } 12751 case BuiltinOptions_SquareOptions: { 12752 value = new SquareOptionsT(*reinterpret_cast<SquareOptionsT *>(u.value)); 12753 break; 12754 } 12755 case BuiltinOptions_ZerosLikeOptions: { 12756 value = new ZerosLikeOptionsT(*reinterpret_cast<ZerosLikeOptionsT *>(u.value)); 12757 break; 12758 } 12759 case BuiltinOptions_FillOptions: { 12760 value = new FillOptionsT(*reinterpret_cast<FillOptionsT *>(u.value)); 12761 break; 12762 } 12763 case BuiltinOptions_BidirectionalSequenceLSTMOptions: { 12764 value = new BidirectionalSequenceLSTMOptionsT(*reinterpret_cast<BidirectionalSequenceLSTMOptionsT *>(u.value)); 12765 break; 12766 } 12767 case BuiltinOptions_BidirectionalSequenceRNNOptions: { 12768 value = new BidirectionalSequenceRNNOptionsT(*reinterpret_cast<BidirectionalSequenceRNNOptionsT *>(u.value)); 12769 break; 12770 } 12771 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: { 12772 value = new UnidirectionalSequenceLSTMOptionsT(*reinterpret_cast<UnidirectionalSequenceLSTMOptionsT *>(u.value)); 12773 break; 12774 } 12775 case BuiltinOptions_FloorModOptions: { 12776 value = new FloorModOptionsT(*reinterpret_cast<FloorModOptionsT *>(u.value)); 12777 break; 12778 } 12779 case BuiltinOptions_RangeOptions: { 12780 value = new RangeOptionsT(*reinterpret_cast<RangeOptionsT *>(u.value)); 12781 break; 12782 } 12783 case BuiltinOptions_ResizeNearestNeighborOptions: { 12784 value = new ResizeNearestNeighborOptionsT(*reinterpret_cast<ResizeNearestNeighborOptionsT *>(u.value)); 12785 break; 12786 } 12787 case BuiltinOptions_LeakyReluOptions: { 12788 value = new LeakyReluOptionsT(*reinterpret_cast<LeakyReluOptionsT *>(u.value)); 12789 break; 12790 } 12791 case BuiltinOptions_SquaredDifferenceOptions: { 12792 value = new SquaredDifferenceOptionsT(*reinterpret_cast<SquaredDifferenceOptionsT *>(u.value)); 12793 break; 12794 } 12795 case BuiltinOptions_MirrorPadOptions: { 12796 value = new MirrorPadOptionsT(*reinterpret_cast<MirrorPadOptionsT *>(u.value)); 12797 break; 12798 } 12799 case BuiltinOptions_AbsOptions: { 12800 value = new AbsOptionsT(*reinterpret_cast<AbsOptionsT *>(u.value)); 12801 break; 12802 } 12803 case BuiltinOptions_SplitVOptions: { 12804 value = new SplitVOptionsT(*reinterpret_cast<SplitVOptionsT *>(u.value)); 12805 break; 12806 } 12807 case BuiltinOptions_UniqueOptions: { 12808 value = new UniqueOptionsT(*reinterpret_cast<UniqueOptionsT *>(u.value)); 12809 break; 12810 } 12811 case BuiltinOptions_ReverseV2Options: { 12812 value = new ReverseV2OptionsT(*reinterpret_cast<ReverseV2OptionsT *>(u.value)); 12813 break; 12814 } 12815 case BuiltinOptions_AddNOptions: { 12816 value = new AddNOptionsT(*reinterpret_cast<AddNOptionsT *>(u.value)); 12817 break; 12818 } 12819 case BuiltinOptions_GatherNdOptions: { 12820 value = new GatherNdOptionsT(*reinterpret_cast<GatherNdOptionsT *>(u.value)); 12821 break; 12822 } 12823 case BuiltinOptions_CosOptions: { 12824 value = new CosOptionsT(*reinterpret_cast<CosOptionsT *>(u.value)); 12825 break; 12826 } 12827 case BuiltinOptions_WhereOptions: { 12828 value = new WhereOptionsT(*reinterpret_cast<WhereOptionsT *>(u.value)); 12829 break; 12830 } 12831 case BuiltinOptions_RankOptions: { 12832 value = new RankOptionsT(*reinterpret_cast<RankOptionsT *>(u.value)); 12833 break; 12834 } 12835 case BuiltinOptions_ReverseSequenceOptions: { 12836 value = new ReverseSequenceOptionsT(*reinterpret_cast<ReverseSequenceOptionsT *>(u.value)); 12837 break; 12838 } 12839 default: 12840 break; 12841 } 12842 } 12843 12844 inline void BuiltinOptionsUnion::Reset() { 12845 switch (type) { 12846 case BuiltinOptions_Conv2DOptions: { 12847 auto ptr = reinterpret_cast<Conv2DOptionsT *>(value); 12848 delete ptr; 12849 break; 12850 } 12851 case BuiltinOptions_DepthwiseConv2DOptions: { 12852 auto ptr = reinterpret_cast<DepthwiseConv2DOptionsT *>(value); 12853 delete ptr; 12854 break; 12855 } 12856 case BuiltinOptions_ConcatEmbeddingsOptions: { 12857 auto ptr = reinterpret_cast<ConcatEmbeddingsOptionsT *>(value); 12858 delete ptr; 12859 break; 12860 } 12861 case BuiltinOptions_LSHProjectionOptions: { 12862 auto ptr = reinterpret_cast<LSHProjectionOptionsT *>(value); 12863 delete ptr; 12864 break; 12865 } 12866 case BuiltinOptions_Pool2DOptions: { 12867 auto ptr = reinterpret_cast<Pool2DOptionsT *>(value); 12868 delete ptr; 12869 break; 12870 } 12871 case BuiltinOptions_SVDFOptions: { 12872 auto ptr = reinterpret_cast<SVDFOptionsT *>(value); 12873 delete ptr; 12874 break; 12875 } 12876 case BuiltinOptions_RNNOptions: { 12877 auto ptr = reinterpret_cast<RNNOptionsT *>(value); 12878 delete ptr; 12879 break; 12880 } 12881 case BuiltinOptions_FullyConnectedOptions: { 12882 auto ptr = reinterpret_cast<FullyConnectedOptionsT *>(value); 12883 delete ptr; 12884 break; 12885 } 12886 case BuiltinOptions_SoftmaxOptions: { 12887 auto ptr = reinterpret_cast<SoftmaxOptionsT *>(value); 12888 delete ptr; 12889 break; 12890 } 12891 case BuiltinOptions_ConcatenationOptions: { 12892 auto ptr = reinterpret_cast<ConcatenationOptionsT *>(value); 12893 delete ptr; 12894 break; 12895 } 12896 case BuiltinOptions_AddOptions: { 12897 auto ptr = reinterpret_cast<AddOptionsT *>(value); 12898 delete ptr; 12899 break; 12900 } 12901 case BuiltinOptions_L2NormOptions: { 12902 auto ptr = reinterpret_cast<L2NormOptionsT *>(value); 12903 delete ptr; 12904 break; 12905 } 12906 case BuiltinOptions_LocalResponseNormalizationOptions: { 12907 auto ptr = reinterpret_cast<LocalResponseNormalizationOptionsT *>(value); 12908 delete ptr; 12909 break; 12910 } 12911 case BuiltinOptions_LSTMOptions: { 12912 auto ptr = reinterpret_cast<LSTMOptionsT *>(value); 12913 delete ptr; 12914 break; 12915 } 12916 case BuiltinOptions_ResizeBilinearOptions: { 12917 auto ptr = reinterpret_cast<ResizeBilinearOptionsT *>(value); 12918 delete ptr; 12919 break; 12920 } 12921 case BuiltinOptions_CallOptions: { 12922 auto ptr = reinterpret_cast<CallOptionsT *>(value); 12923 delete ptr; 12924 break; 12925 } 12926 case BuiltinOptions_ReshapeOptions: { 12927 auto ptr = reinterpret_cast<ReshapeOptionsT *>(value); 12928 delete ptr; 12929 break; 12930 } 12931 case BuiltinOptions_SkipGramOptions: { 12932 auto ptr = reinterpret_cast<SkipGramOptionsT *>(value); 12933 delete ptr; 12934 break; 12935 } 12936 case BuiltinOptions_SpaceToDepthOptions: { 12937 auto ptr = reinterpret_cast<SpaceToDepthOptionsT *>(value); 12938 delete ptr; 12939 break; 12940 } 12941 case BuiltinOptions_EmbeddingLookupSparseOptions: { 12942 auto ptr = reinterpret_cast<EmbeddingLookupSparseOptionsT *>(value); 12943 delete ptr; 12944 break; 12945 } 12946 case BuiltinOptions_MulOptions: { 12947 auto ptr = reinterpret_cast<MulOptionsT *>(value); 12948 delete ptr; 12949 break; 12950 } 12951 case BuiltinOptions_PadOptions: { 12952 auto ptr = reinterpret_cast<PadOptionsT *>(value); 12953 delete ptr; 12954 break; 12955 } 12956 case BuiltinOptions_GatherOptions: { 12957 auto ptr = reinterpret_cast<GatherOptionsT *>(value); 12958 delete ptr; 12959 break; 12960 } 12961 case BuiltinOptions_BatchToSpaceNDOptions: { 12962 auto ptr = reinterpret_cast<BatchToSpaceNDOptionsT *>(value); 12963 delete ptr; 12964 break; 12965 } 12966 case BuiltinOptions_SpaceToBatchNDOptions: { 12967 auto ptr = reinterpret_cast<SpaceToBatchNDOptionsT *>(value); 12968 delete ptr; 12969 break; 12970 } 12971 case BuiltinOptions_TransposeOptions: { 12972 auto ptr = reinterpret_cast<TransposeOptionsT *>(value); 12973 delete ptr; 12974 break; 12975 } 12976 case BuiltinOptions_ReducerOptions: { 12977 auto ptr = reinterpret_cast<ReducerOptionsT *>(value); 12978 delete ptr; 12979 break; 12980 } 12981 case BuiltinOptions_SubOptions: { 12982 auto ptr = reinterpret_cast<SubOptionsT *>(value); 12983 delete ptr; 12984 break; 12985 } 12986 case BuiltinOptions_DivOptions: { 12987 auto ptr = reinterpret_cast<DivOptionsT *>(value); 12988 delete ptr; 12989 break; 12990 } 12991 case BuiltinOptions_SqueezeOptions: { 12992 auto ptr = reinterpret_cast<SqueezeOptionsT *>(value); 12993 delete ptr; 12994 break; 12995 } 12996 case BuiltinOptions_SequenceRNNOptions: { 12997 auto ptr = reinterpret_cast<SequenceRNNOptionsT *>(value); 12998 delete ptr; 12999 break; 13000 } 13001 case BuiltinOptions_StridedSliceOptions: { 13002 auto ptr = reinterpret_cast<StridedSliceOptionsT *>(value); 13003 delete ptr; 13004 break; 13005 } 13006 case BuiltinOptions_ExpOptions: { 13007 auto ptr = reinterpret_cast<ExpOptionsT *>(value); 13008 delete ptr; 13009 break; 13010 } 13011 case BuiltinOptions_TopKV2Options: { 13012 auto ptr = reinterpret_cast<TopKV2OptionsT *>(value); 13013 delete ptr; 13014 break; 13015 } 13016 case BuiltinOptions_SplitOptions: { 13017 auto ptr = reinterpret_cast<SplitOptionsT *>(value); 13018 delete ptr; 13019 break; 13020 } 13021 case BuiltinOptions_LogSoftmaxOptions: { 13022 auto ptr = reinterpret_cast<LogSoftmaxOptionsT *>(value); 13023 delete ptr; 13024 break; 13025 } 13026 case BuiltinOptions_CastOptions: { 13027 auto ptr = reinterpret_cast<CastOptionsT *>(value); 13028 delete ptr; 13029 break; 13030 } 13031 case BuiltinOptions_DequantizeOptions: { 13032 auto ptr = reinterpret_cast<DequantizeOptionsT *>(value); 13033 delete ptr; 13034 break; 13035 } 13036 case BuiltinOptions_MaximumMinimumOptions: { 13037 auto ptr = reinterpret_cast<MaximumMinimumOptionsT *>(value); 13038 delete ptr; 13039 break; 13040 } 13041 case BuiltinOptions_ArgMaxOptions: { 13042 auto ptr = reinterpret_cast<ArgMaxOptionsT *>(value); 13043 delete ptr; 13044 break; 13045 } 13046 case BuiltinOptions_LessOptions: { 13047 auto ptr = reinterpret_cast<LessOptionsT *>(value); 13048 delete ptr; 13049 break; 13050 } 13051 case BuiltinOptions_NegOptions: { 13052 auto ptr = reinterpret_cast<NegOptionsT *>(value); 13053 delete ptr; 13054 break; 13055 } 13056 case BuiltinOptions_PadV2Options: { 13057 auto ptr = reinterpret_cast<PadV2OptionsT *>(value); 13058 delete ptr; 13059 break; 13060 } 13061 case BuiltinOptions_GreaterOptions: { 13062 auto ptr = reinterpret_cast<GreaterOptionsT *>(value); 13063 delete ptr; 13064 break; 13065 } 13066 case BuiltinOptions_GreaterEqualOptions: { 13067 auto ptr = reinterpret_cast<GreaterEqualOptionsT *>(value); 13068 delete ptr; 13069 break; 13070 } 13071 case BuiltinOptions_LessEqualOptions: { 13072 auto ptr = reinterpret_cast<LessEqualOptionsT *>(value); 13073 delete ptr; 13074 break; 13075 } 13076 case BuiltinOptions_SelectOptions: { 13077 auto ptr = reinterpret_cast<SelectOptionsT *>(value); 13078 delete ptr; 13079 break; 13080 } 13081 case BuiltinOptions_SliceOptions: { 13082 auto ptr = reinterpret_cast<SliceOptionsT *>(value); 13083 delete ptr; 13084 break; 13085 } 13086 case BuiltinOptions_TransposeConvOptions: { 13087 auto ptr = reinterpret_cast<TransposeConvOptionsT *>(value); 13088 delete ptr; 13089 break; 13090 } 13091 case BuiltinOptions_SparseToDenseOptions: { 13092 auto ptr = reinterpret_cast<SparseToDenseOptionsT *>(value); 13093 delete ptr; 13094 break; 13095 } 13096 case BuiltinOptions_TileOptions: { 13097 auto ptr = reinterpret_cast<TileOptionsT *>(value); 13098 delete ptr; 13099 break; 13100 } 13101 case BuiltinOptions_ExpandDimsOptions: { 13102 auto ptr = reinterpret_cast<ExpandDimsOptionsT *>(value); 13103 delete ptr; 13104 break; 13105 } 13106 case BuiltinOptions_EqualOptions: { 13107 auto ptr = reinterpret_cast<EqualOptionsT *>(value); 13108 delete ptr; 13109 break; 13110 } 13111 case BuiltinOptions_NotEqualOptions: { 13112 auto ptr = reinterpret_cast<NotEqualOptionsT *>(value); 13113 delete ptr; 13114 break; 13115 } 13116 case BuiltinOptions_ShapeOptions: { 13117 auto ptr = reinterpret_cast<ShapeOptionsT *>(value); 13118 delete ptr; 13119 break; 13120 } 13121 case BuiltinOptions_PowOptions: { 13122 auto ptr = reinterpret_cast<PowOptionsT *>(value); 13123 delete ptr; 13124 break; 13125 } 13126 case BuiltinOptions_ArgMinOptions: { 13127 auto ptr = reinterpret_cast<ArgMinOptionsT *>(value); 13128 delete ptr; 13129 break; 13130 } 13131 case BuiltinOptions_FakeQuantOptions: { 13132 auto ptr = reinterpret_cast<FakeQuantOptionsT *>(value); 13133 delete ptr; 13134 break; 13135 } 13136 case BuiltinOptions_PackOptions: { 13137 auto ptr = reinterpret_cast<PackOptionsT *>(value); 13138 delete ptr; 13139 break; 13140 } 13141 case BuiltinOptions_LogicalOrOptions: { 13142 auto ptr = reinterpret_cast<LogicalOrOptionsT *>(value); 13143 delete ptr; 13144 break; 13145 } 13146 case BuiltinOptions_OneHotOptions: { 13147 auto ptr = reinterpret_cast<OneHotOptionsT *>(value); 13148 delete ptr; 13149 break; 13150 } 13151 case BuiltinOptions_LogicalAndOptions: { 13152 auto ptr = reinterpret_cast<LogicalAndOptionsT *>(value); 13153 delete ptr; 13154 break; 13155 } 13156 case BuiltinOptions_LogicalNotOptions: { 13157 auto ptr = reinterpret_cast<LogicalNotOptionsT *>(value); 13158 delete ptr; 13159 break; 13160 } 13161 case BuiltinOptions_UnpackOptions: { 13162 auto ptr = reinterpret_cast<UnpackOptionsT *>(value); 13163 delete ptr; 13164 break; 13165 } 13166 case BuiltinOptions_FloorDivOptions: { 13167 auto ptr = reinterpret_cast<FloorDivOptionsT *>(value); 13168 delete ptr; 13169 break; 13170 } 13171 case BuiltinOptions_SquareOptions: { 13172 auto ptr = reinterpret_cast<SquareOptionsT *>(value); 13173 delete ptr; 13174 break; 13175 } 13176 case BuiltinOptions_ZerosLikeOptions: { 13177 auto ptr = reinterpret_cast<ZerosLikeOptionsT *>(value); 13178 delete ptr; 13179 break; 13180 } 13181 case BuiltinOptions_FillOptions: { 13182 auto ptr = reinterpret_cast<FillOptionsT *>(value); 13183 delete ptr; 13184 break; 13185 } 13186 case BuiltinOptions_BidirectionalSequenceLSTMOptions: { 13187 auto ptr = reinterpret_cast<BidirectionalSequenceLSTMOptionsT *>(value); 13188 delete ptr; 13189 break; 13190 } 13191 case BuiltinOptions_BidirectionalSequenceRNNOptions: { 13192 auto ptr = reinterpret_cast<BidirectionalSequenceRNNOptionsT *>(value); 13193 delete ptr; 13194 break; 13195 } 13196 case BuiltinOptions_UnidirectionalSequenceLSTMOptions: { 13197 auto ptr = reinterpret_cast<UnidirectionalSequenceLSTMOptionsT *>(value); 13198 delete ptr; 13199 break; 13200 } 13201 case BuiltinOptions_FloorModOptions: { 13202 auto ptr = reinterpret_cast<FloorModOptionsT *>(value); 13203 delete ptr; 13204 break; 13205 } 13206 case BuiltinOptions_RangeOptions: { 13207 auto ptr = reinterpret_cast<RangeOptionsT *>(value); 13208 delete ptr; 13209 break; 13210 } 13211 case BuiltinOptions_ResizeNearestNeighborOptions: { 13212 auto ptr = reinterpret_cast<ResizeNearestNeighborOptionsT *>(value); 13213 delete ptr; 13214 break; 13215 } 13216 case BuiltinOptions_LeakyReluOptions: { 13217 auto ptr = reinterpret_cast<LeakyReluOptionsT *>(value); 13218 delete ptr; 13219 break; 13220 } 13221 case BuiltinOptions_SquaredDifferenceOptions: { 13222 auto ptr = reinterpret_cast<SquaredDifferenceOptionsT *>(value); 13223 delete ptr; 13224 break; 13225 } 13226 case BuiltinOptions_MirrorPadOptions: { 13227 auto ptr = reinterpret_cast<MirrorPadOptionsT *>(value); 13228 delete ptr; 13229 break; 13230 } 13231 case BuiltinOptions_AbsOptions: { 13232 auto ptr = reinterpret_cast<AbsOptionsT *>(value); 13233 delete ptr; 13234 break; 13235 } 13236 case BuiltinOptions_SplitVOptions: { 13237 auto ptr = reinterpret_cast<SplitVOptionsT *>(value); 13238 delete ptr; 13239 break; 13240 } 13241 case BuiltinOptions_UniqueOptions: { 13242 auto ptr = reinterpret_cast<UniqueOptionsT *>(value); 13243 delete ptr; 13244 break; 13245 } 13246 case BuiltinOptions_ReverseV2Options: { 13247 auto ptr = reinterpret_cast<ReverseV2OptionsT *>(value); 13248 delete ptr; 13249 break; 13250 } 13251 case BuiltinOptions_AddNOptions: { 13252 auto ptr = reinterpret_cast<AddNOptionsT *>(value); 13253 delete ptr; 13254 break; 13255 } 13256 case BuiltinOptions_GatherNdOptions: { 13257 auto ptr = reinterpret_cast<GatherNdOptionsT *>(value); 13258 delete ptr; 13259 break; 13260 } 13261 case BuiltinOptions_CosOptions: { 13262 auto ptr = reinterpret_cast<CosOptionsT *>(value); 13263 delete ptr; 13264 break; 13265 } 13266 case BuiltinOptions_WhereOptions: { 13267 auto ptr = reinterpret_cast<WhereOptionsT *>(value); 13268 delete ptr; 13269 break; 13270 } 13271 case BuiltinOptions_RankOptions: { 13272 auto ptr = reinterpret_cast<RankOptionsT *>(value); 13273 delete ptr; 13274 break; 13275 } 13276 case BuiltinOptions_ReverseSequenceOptions: { 13277 auto ptr = reinterpret_cast<ReverseSequenceOptionsT *>(value); 13278 delete ptr; 13279 break; 13280 } 13281 default: break; 13282 } 13283 value = nullptr; 13284 type = BuiltinOptions_NONE; 13285 } 13286 13287 inline const tflite::Model *GetModel(const void *buf) { 13288 return flatbuffers::GetRoot<tflite::Model>(buf); 13289 } 13290 13291 inline const tflite::Model *GetSizePrefixedModel(const void *buf) { 13292 return flatbuffers::GetSizePrefixedRoot<tflite::Model>(buf); 13293 } 13294 13295 inline const char *ModelIdentifier() { 13296 return "TFL3"; 13297 } 13298 13299 inline bool ModelBufferHasIdentifier(const void *buf) { 13300 return flatbuffers::BufferHasIdentifier( 13301 buf, ModelIdentifier()); 13302 } 13303 13304 inline bool VerifyModelBuffer( 13305 flatbuffers::Verifier &verifier) { 13306 return verifier.VerifyBuffer<tflite::Model>(ModelIdentifier()); 13307 } 13308 13309 inline bool VerifySizePrefixedModelBuffer( 13310 flatbuffers::Verifier &verifier) { 13311 return verifier.VerifySizePrefixedBuffer<tflite::Model>(ModelIdentifier()); 13312 } 13313 13314 inline const char *ModelExtension() { 13315 return "tflite"; 13316 } 13317 13318 inline void FinishModelBuffer( 13319 flatbuffers::FlatBufferBuilder &fbb, 13320 flatbuffers::Offset<tflite::Model> root) { 13321 fbb.Finish(root, ModelIdentifier()); 13322 } 13323 13324 inline void FinishSizePrefixedModelBuffer( 13325 flatbuffers::FlatBufferBuilder &fbb, 13326 flatbuffers::Offset<tflite::Model> root) { 13327 fbb.FinishSizePrefixed(root, ModelIdentifier()); 13328 } 13329 13330 inline std::unique_ptr<ModelT> UnPackModel( 13331 const void *buf, 13332 const flatbuffers::resolver_function_t *res = nullptr) { 13333 return std::unique_ptr<ModelT>(GetModel(buf)->UnPack(res)); 13334 } 13335 13336 } // namespace tflite 13337 13338 #endif // FLATBUFFERS_GENERATED_SCHEMA_TFLITE_H_ 13339
