1 // automatically generated by the FlatBuffers compiler, do not modify
2
3
4 #ifndef FLATBUFFERS_GENERATED_METADATASCHEMA_TFLITE_H_
5 #define FLATBUFFERS_GENERATED_METADATASCHEMA_TFLITE_H_
6
7 #include "flatbuffers/flatbuffers.h"
8
9 // Ensure the included flatbuffers.h is the same version as when this file was
10 // generated, otherwise it may not be compatible.
11 static_assert(FLATBUFFERS_VERSION_MAJOR == 2 &&
12 FLATBUFFERS_VERSION_MINOR == 0 &&
13 FLATBUFFERS_VERSION_REVISION == 7,
14 "Non-compatible flatbuffers version included");
15
16 namespace tflite {
17
18 struct AssociatedFile;
19 struct AssociatedFileBuilder;
20 struct AssociatedFileT;
21
22 struct FeatureProperties;
23 struct FeaturePropertiesBuilder;
24 struct FeaturePropertiesT;
25
26 struct ImageSize;
27 struct ImageSizeBuilder;
28 struct ImageSizeT;
29
30 struct ImageProperties;
31 struct ImagePropertiesBuilder;
32 struct ImagePropertiesT;
33
34 struct AudioProperties;
35 struct AudioPropertiesBuilder;
36 struct AudioPropertiesT;
37
38 struct BoundingBoxProperties;
39 struct BoundingBoxPropertiesBuilder;
40 struct BoundingBoxPropertiesT;
41
42 struct ValueRange;
43 struct ValueRangeBuilder;
44 struct ValueRangeT;
45
46 struct Content;
47 struct ContentBuilder;
48 struct ContentT;
49
50 struct NormalizationOptions;
51 struct NormalizationOptionsBuilder;
52 struct NormalizationOptionsT;
53
54 struct ScoreCalibrationOptions;
55 struct ScoreCalibrationOptionsBuilder;
56 struct ScoreCalibrationOptionsT;
57
58 struct ScoreThresholdingOptions;
59 struct ScoreThresholdingOptionsBuilder;
60 struct ScoreThresholdingOptionsT;
61
62 struct BertTokenizerOptions;
63 struct BertTokenizerOptionsBuilder;
64 struct BertTokenizerOptionsT;
65
66 struct SentencePieceTokenizerOptions;
67 struct SentencePieceTokenizerOptionsBuilder;
68 struct SentencePieceTokenizerOptionsT;
69
70 struct RegexTokenizerOptions;
71 struct RegexTokenizerOptionsBuilder;
72 struct RegexTokenizerOptionsT;
73
74 struct ProcessUnit;
75 struct ProcessUnitBuilder;
76 struct ProcessUnitT;
77
78 struct Stats;
79 struct StatsBuilder;
80 struct StatsT;
81
82 struct TensorGroup;
83 struct TensorGroupBuilder;
84 struct TensorGroupT;
85
86 struct TensorMetadata;
87 struct TensorMetadataBuilder;
88 struct TensorMetadataT;
89
90 struct SubGraphMetadata;
91 struct SubGraphMetadataBuilder;
92 struct SubGraphMetadataT;
93
94 struct ModelMetadata;
95 struct ModelMetadataBuilder;
96 struct ModelMetadataT;
97
98 enum AssociatedFileType : int8_t {
99 AssociatedFileType_UNKNOWN = 0,
100 AssociatedFileType_DESCRIPTIONS = 1,
101 AssociatedFileType_TENSOR_AXIS_LABELS = 2,
102 AssociatedFileType_TENSOR_VALUE_LABELS = 3,
103 AssociatedFileType_TENSOR_AXIS_SCORE_CALIBRATION = 4,
104 AssociatedFileType_VOCABULARY = 5,
105 AssociatedFileType_SCANN_INDEX_FILE = 6,
106 AssociatedFileType_MIN = AssociatedFileType_UNKNOWN,
107 AssociatedFileType_MAX = AssociatedFileType_SCANN_INDEX_FILE
108 };
109
EnumValuesAssociatedFileType()110 inline const AssociatedFileType (&EnumValuesAssociatedFileType())[7] {
111 static const AssociatedFileType values[] = {
112 AssociatedFileType_UNKNOWN,
113 AssociatedFileType_DESCRIPTIONS,
114 AssociatedFileType_TENSOR_AXIS_LABELS,
115 AssociatedFileType_TENSOR_VALUE_LABELS,
116 AssociatedFileType_TENSOR_AXIS_SCORE_CALIBRATION,
117 AssociatedFileType_VOCABULARY,
118 AssociatedFileType_SCANN_INDEX_FILE
119 };
120 return values;
121 }
122
EnumNamesAssociatedFileType()123 inline const char * const *EnumNamesAssociatedFileType() {
124 static const char * const names[8] = {
125 "UNKNOWN",
126 "DESCRIPTIONS",
127 "TENSOR_AXIS_LABELS",
128 "TENSOR_VALUE_LABELS",
129 "TENSOR_AXIS_SCORE_CALIBRATION",
130 "VOCABULARY",
131 "SCANN_INDEX_FILE",
132 nullptr
133 };
134 return names;
135 }
136
EnumNameAssociatedFileType(AssociatedFileType e)137 inline const char *EnumNameAssociatedFileType(AssociatedFileType e) {
138 if (flatbuffers::IsOutRange(e, AssociatedFileType_UNKNOWN, AssociatedFileType_SCANN_INDEX_FILE)) return "";
139 const size_t index = static_cast<size_t>(e);
140 return EnumNamesAssociatedFileType()[index];
141 }
142
143 enum ColorSpaceType : int8_t {
144 ColorSpaceType_UNKNOWN = 0,
145 ColorSpaceType_RGB = 1,
146 ColorSpaceType_GRAYSCALE = 2,
147 ColorSpaceType_MIN = ColorSpaceType_UNKNOWN,
148 ColorSpaceType_MAX = ColorSpaceType_GRAYSCALE
149 };
150
EnumValuesColorSpaceType()151 inline const ColorSpaceType (&EnumValuesColorSpaceType())[3] {
152 static const ColorSpaceType values[] = {
153 ColorSpaceType_UNKNOWN,
154 ColorSpaceType_RGB,
155 ColorSpaceType_GRAYSCALE
156 };
157 return values;
158 }
159
EnumNamesColorSpaceType()160 inline const char * const *EnumNamesColorSpaceType() {
161 static const char * const names[4] = {
162 "UNKNOWN",
163 "RGB",
164 "GRAYSCALE",
165 nullptr
166 };
167 return names;
168 }
169
EnumNameColorSpaceType(ColorSpaceType e)170 inline const char *EnumNameColorSpaceType(ColorSpaceType e) {
171 if (flatbuffers::IsOutRange(e, ColorSpaceType_UNKNOWN, ColorSpaceType_GRAYSCALE)) return "";
172 const size_t index = static_cast<size_t>(e);
173 return EnumNamesColorSpaceType()[index];
174 }
175
176 enum BoundingBoxType : int8_t {
177 BoundingBoxType_UNKNOWN = 0,
178 BoundingBoxType_BOUNDARIES = 1,
179 BoundingBoxType_UPPER_LEFT = 2,
180 BoundingBoxType_CENTER = 3,
181 BoundingBoxType_MIN = BoundingBoxType_UNKNOWN,
182 BoundingBoxType_MAX = BoundingBoxType_CENTER
183 };
184
EnumValuesBoundingBoxType()185 inline const BoundingBoxType (&EnumValuesBoundingBoxType())[4] {
186 static const BoundingBoxType values[] = {
187 BoundingBoxType_UNKNOWN,
188 BoundingBoxType_BOUNDARIES,
189 BoundingBoxType_UPPER_LEFT,
190 BoundingBoxType_CENTER
191 };
192 return values;
193 }
194
EnumNamesBoundingBoxType()195 inline const char * const *EnumNamesBoundingBoxType() {
196 static const char * const names[5] = {
197 "UNKNOWN",
198 "BOUNDARIES",
199 "UPPER_LEFT",
200 "CENTER",
201 nullptr
202 };
203 return names;
204 }
205
EnumNameBoundingBoxType(BoundingBoxType e)206 inline const char *EnumNameBoundingBoxType(BoundingBoxType e) {
207 if (flatbuffers::IsOutRange(e, BoundingBoxType_UNKNOWN, BoundingBoxType_CENTER)) return "";
208 const size_t index = static_cast<size_t>(e);
209 return EnumNamesBoundingBoxType()[index];
210 }
211
212 enum CoordinateType : int8_t {
213 CoordinateType_RATIO = 0,
214 CoordinateType_PIXEL = 1,
215 CoordinateType_MIN = CoordinateType_RATIO,
216 CoordinateType_MAX = CoordinateType_PIXEL
217 };
218
EnumValuesCoordinateType()219 inline const CoordinateType (&EnumValuesCoordinateType())[2] {
220 static const CoordinateType values[] = {
221 CoordinateType_RATIO,
222 CoordinateType_PIXEL
223 };
224 return values;
225 }
226
EnumNamesCoordinateType()227 inline const char * const *EnumNamesCoordinateType() {
228 static const char * const names[3] = {
229 "RATIO",
230 "PIXEL",
231 nullptr
232 };
233 return names;
234 }
235
EnumNameCoordinateType(CoordinateType e)236 inline const char *EnumNameCoordinateType(CoordinateType e) {
237 if (flatbuffers::IsOutRange(e, CoordinateType_RATIO, CoordinateType_PIXEL)) return "";
238 const size_t index = static_cast<size_t>(e);
239 return EnumNamesCoordinateType()[index];
240 }
241
242 enum ContentProperties : uint8_t {
243 ContentProperties_NONE = 0,
244 ContentProperties_FeatureProperties = 1,
245 ContentProperties_ImageProperties = 2,
246 ContentProperties_BoundingBoxProperties = 3,
247 ContentProperties_AudioProperties = 4,
248 ContentProperties_MIN = ContentProperties_NONE,
249 ContentProperties_MAX = ContentProperties_AudioProperties
250 };
251
EnumValuesContentProperties()252 inline const ContentProperties (&EnumValuesContentProperties())[5] {
253 static const ContentProperties values[] = {
254 ContentProperties_NONE,
255 ContentProperties_FeatureProperties,
256 ContentProperties_ImageProperties,
257 ContentProperties_BoundingBoxProperties,
258 ContentProperties_AudioProperties
259 };
260 return values;
261 }
262
EnumNamesContentProperties()263 inline const char * const *EnumNamesContentProperties() {
264 static const char * const names[6] = {
265 "NONE",
266 "FeatureProperties",
267 "ImageProperties",
268 "BoundingBoxProperties",
269 "AudioProperties",
270 nullptr
271 };
272 return names;
273 }
274
EnumNameContentProperties(ContentProperties e)275 inline const char *EnumNameContentProperties(ContentProperties e) {
276 if (flatbuffers::IsOutRange(e, ContentProperties_NONE, ContentProperties_AudioProperties)) return "";
277 const size_t index = static_cast<size_t>(e);
278 return EnumNamesContentProperties()[index];
279 }
280
281 template<typename T> struct ContentPropertiesTraits {
282 static const ContentProperties enum_value = ContentProperties_NONE;
283 };
284
285 template<> struct ContentPropertiesTraits<tflite::FeatureProperties> {
286 static const ContentProperties enum_value = ContentProperties_FeatureProperties;
287 };
288
289 template<> struct ContentPropertiesTraits<tflite::ImageProperties> {
290 static const ContentProperties enum_value = ContentProperties_ImageProperties;
291 };
292
293 template<> struct ContentPropertiesTraits<tflite::BoundingBoxProperties> {
294 static const ContentProperties enum_value = ContentProperties_BoundingBoxProperties;
295 };
296
297 template<> struct ContentPropertiesTraits<tflite::AudioProperties> {
298 static const ContentProperties enum_value = ContentProperties_AudioProperties;
299 };
300
301 template<typename T> struct ContentPropertiesUnionTraits {
302 static const ContentProperties enum_value = ContentProperties_NONE;
303 };
304
305 template<> struct ContentPropertiesUnionTraits<tflite::FeaturePropertiesT> {
306 static const ContentProperties enum_value = ContentProperties_FeatureProperties;
307 };
308
309 template<> struct ContentPropertiesUnionTraits<tflite::ImagePropertiesT> {
310 static const ContentProperties enum_value = ContentProperties_ImageProperties;
311 };
312
313 template<> struct ContentPropertiesUnionTraits<tflite::BoundingBoxPropertiesT> {
314 static const ContentProperties enum_value = ContentProperties_BoundingBoxProperties;
315 };
316
317 template<> struct ContentPropertiesUnionTraits<tflite::AudioPropertiesT> {
318 static const ContentProperties enum_value = ContentProperties_AudioProperties;
319 };
320
321 struct ContentPropertiesUnion {
322 ContentProperties type;
323 void *value;
324
325 ContentPropertiesUnion() : type(ContentProperties_NONE), value(nullptr) {}
326 ContentPropertiesUnion(ContentPropertiesUnion&& u) FLATBUFFERS_NOEXCEPT :
327 type(ContentProperties_NONE), value(nullptr)
328 { std::swap(type, u.type); std::swap(value, u.value); }
329 ContentPropertiesUnion(const ContentPropertiesUnion &);
330 ContentPropertiesUnion &operator=(const ContentPropertiesUnion &u)
331 { ContentPropertiesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
332 ContentPropertiesUnion &operator=(ContentPropertiesUnion &&u) FLATBUFFERS_NOEXCEPT
333 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
334 ~ContentPropertiesUnion() { Reset(); }
335
336 void Reset();
337
338 template <typename T>
339 void Set(T&& val) {
340 typedef typename std::remove_reference<T>::type RT;
341 Reset();
342 type = ContentPropertiesUnionTraits<RT>::enum_value;
343 if (type != ContentProperties_NONE) {
344 value = new RT(std::forward<T>(val));
345 }
346 }
347
348 static void *UnPack(const void *obj, ContentProperties type, const flatbuffers::resolver_function_t *resolver);
349 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
350
351 tflite::FeaturePropertiesT *AsFeatureProperties() {
352 return type == ContentProperties_FeatureProperties ?
353 reinterpret_cast<tflite::FeaturePropertiesT *>(value) : nullptr;
354 }
355 const tflite::FeaturePropertiesT *AsFeatureProperties() const {
356 return type == ContentProperties_FeatureProperties ?
357 reinterpret_cast<const tflite::FeaturePropertiesT *>(value) : nullptr;
358 }
359 tflite::ImagePropertiesT *AsImageProperties() {
360 return type == ContentProperties_ImageProperties ?
361 reinterpret_cast<tflite::ImagePropertiesT *>(value) : nullptr;
362 }
363 const tflite::ImagePropertiesT *AsImageProperties() const {
364 return type == ContentProperties_ImageProperties ?
365 reinterpret_cast<const tflite::ImagePropertiesT *>(value) : nullptr;
366 }
367 tflite::BoundingBoxPropertiesT *AsBoundingBoxProperties() {
368 return type == ContentProperties_BoundingBoxProperties ?
369 reinterpret_cast<tflite::BoundingBoxPropertiesT *>(value) : nullptr;
370 }
371 const tflite::BoundingBoxPropertiesT *AsBoundingBoxProperties() const {
372 return type == ContentProperties_BoundingBoxProperties ?
373 reinterpret_cast<const tflite::BoundingBoxPropertiesT *>(value) : nullptr;
374 }
375 tflite::AudioPropertiesT *AsAudioProperties() {
376 return type == ContentProperties_AudioProperties ?
377 reinterpret_cast<tflite::AudioPropertiesT *>(value) : nullptr;
378 }
379 const tflite::AudioPropertiesT *AsAudioProperties() const {
380 return type == ContentProperties_AudioProperties ?
381 reinterpret_cast<const tflite::AudioPropertiesT *>(value) : nullptr;
382 }
383 };
384
385 bool VerifyContentProperties(flatbuffers::Verifier &verifier, const void *obj, ContentProperties type);
386 bool VerifyContentPropertiesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
387
388 enum ScoreTransformationType : int8_t {
389 ScoreTransformationType_IDENTITY = 0,
390 ScoreTransformationType_LOG = 1,
391 ScoreTransformationType_INVERSE_LOGISTIC = 2,
392 ScoreTransformationType_MIN = ScoreTransformationType_IDENTITY,
393 ScoreTransformationType_MAX = ScoreTransformationType_INVERSE_LOGISTIC
394 };
395
396 inline const ScoreTransformationType (&EnumValuesScoreTransformationType())[3] {
397 static const ScoreTransformationType values[] = {
398 ScoreTransformationType_IDENTITY,
399 ScoreTransformationType_LOG,
400 ScoreTransformationType_INVERSE_LOGISTIC
401 };
402 return values;
403 }
404
405 inline const char * const *EnumNamesScoreTransformationType() {
406 static const char * const names[4] = {
407 "IDENTITY",
408 "LOG",
409 "INVERSE_LOGISTIC",
410 nullptr
411 };
412 return names;
413 }
414
415 inline const char *EnumNameScoreTransformationType(ScoreTransformationType e) {
416 if (flatbuffers::IsOutRange(e, ScoreTransformationType_IDENTITY, ScoreTransformationType_INVERSE_LOGISTIC)) return "";
417 const size_t index = static_cast<size_t>(e);
418 return EnumNamesScoreTransformationType()[index];
419 }
420
421 enum ProcessUnitOptions : uint8_t {
422 ProcessUnitOptions_NONE = 0,
423 ProcessUnitOptions_NormalizationOptions = 1,
424 ProcessUnitOptions_ScoreCalibrationOptions = 2,
425 ProcessUnitOptions_ScoreThresholdingOptions = 3,
426 ProcessUnitOptions_BertTokenizerOptions = 4,
427 ProcessUnitOptions_SentencePieceTokenizerOptions = 5,
428 ProcessUnitOptions_RegexTokenizerOptions = 6,
429 ProcessUnitOptions_MIN = ProcessUnitOptions_NONE,
430 ProcessUnitOptions_MAX = ProcessUnitOptions_RegexTokenizerOptions
431 };
432
433 inline const ProcessUnitOptions (&EnumValuesProcessUnitOptions())[7] {
434 static const ProcessUnitOptions values[] = {
435 ProcessUnitOptions_NONE,
436 ProcessUnitOptions_NormalizationOptions,
437 ProcessUnitOptions_ScoreCalibrationOptions,
438 ProcessUnitOptions_ScoreThresholdingOptions,
439 ProcessUnitOptions_BertTokenizerOptions,
440 ProcessUnitOptions_SentencePieceTokenizerOptions,
441 ProcessUnitOptions_RegexTokenizerOptions
442 };
443 return values;
444 }
445
446 inline const char * const *EnumNamesProcessUnitOptions() {
447 static const char * const names[8] = {
448 "NONE",
449 "NormalizationOptions",
450 "ScoreCalibrationOptions",
451 "ScoreThresholdingOptions",
452 "BertTokenizerOptions",
453 "SentencePieceTokenizerOptions",
454 "RegexTokenizerOptions",
455 nullptr
456 };
457 return names;
458 }
459
460 inline const char *EnumNameProcessUnitOptions(ProcessUnitOptions e) {
461 if (flatbuffers::IsOutRange(e, ProcessUnitOptions_NONE, ProcessUnitOptions_RegexTokenizerOptions)) return "";
462 const size_t index = static_cast<size_t>(e);
463 return EnumNamesProcessUnitOptions()[index];
464 }
465
466 template<typename T> struct ProcessUnitOptionsTraits {
467 static const ProcessUnitOptions enum_value = ProcessUnitOptions_NONE;
468 };
469
470 template<> struct ProcessUnitOptionsTraits<tflite::NormalizationOptions> {
471 static const ProcessUnitOptions enum_value = ProcessUnitOptions_NormalizationOptions;
472 };
473
474 template<> struct ProcessUnitOptionsTraits<tflite::ScoreCalibrationOptions> {
475 static const ProcessUnitOptions enum_value = ProcessUnitOptions_ScoreCalibrationOptions;
476 };
477
478 template<> struct ProcessUnitOptionsTraits<tflite::ScoreThresholdingOptions> {
479 static const ProcessUnitOptions enum_value = ProcessUnitOptions_ScoreThresholdingOptions;
480 };
481
482 template<> struct ProcessUnitOptionsTraits<tflite::BertTokenizerOptions> {
483 static const ProcessUnitOptions enum_value = ProcessUnitOptions_BertTokenizerOptions;
484 };
485
486 template<> struct ProcessUnitOptionsTraits<tflite::SentencePieceTokenizerOptions> {
487 static const ProcessUnitOptions enum_value = ProcessUnitOptions_SentencePieceTokenizerOptions;
488 };
489
490 template<> struct ProcessUnitOptionsTraits<tflite::RegexTokenizerOptions> {
491 static const ProcessUnitOptions enum_value = ProcessUnitOptions_RegexTokenizerOptions;
492 };
493
494 template<typename T> struct ProcessUnitOptionsUnionTraits {
495 static const ProcessUnitOptions enum_value = ProcessUnitOptions_NONE;
496 };
497
498 template<> struct ProcessUnitOptionsUnionTraits<tflite::NormalizationOptionsT> {
499 static const ProcessUnitOptions enum_value = ProcessUnitOptions_NormalizationOptions;
500 };
501
502 template<> struct ProcessUnitOptionsUnionTraits<tflite::ScoreCalibrationOptionsT> {
503 static const ProcessUnitOptions enum_value = ProcessUnitOptions_ScoreCalibrationOptions;
504 };
505
506 template<> struct ProcessUnitOptionsUnionTraits<tflite::ScoreThresholdingOptionsT> {
507 static const ProcessUnitOptions enum_value = ProcessUnitOptions_ScoreThresholdingOptions;
508 };
509
510 template<> struct ProcessUnitOptionsUnionTraits<tflite::BertTokenizerOptionsT> {
511 static const ProcessUnitOptions enum_value = ProcessUnitOptions_BertTokenizerOptions;
512 };
513
514 template<> struct ProcessUnitOptionsUnionTraits<tflite::SentencePieceTokenizerOptionsT> {
515 static const ProcessUnitOptions enum_value = ProcessUnitOptions_SentencePieceTokenizerOptions;
516 };
517
518 template<> struct ProcessUnitOptionsUnionTraits<tflite::RegexTokenizerOptionsT> {
519 static const ProcessUnitOptions enum_value = ProcessUnitOptions_RegexTokenizerOptions;
520 };
521
522 struct ProcessUnitOptionsUnion {
523 ProcessUnitOptions type;
524 void *value;
525
526 ProcessUnitOptionsUnion() : type(ProcessUnitOptions_NONE), value(nullptr) {}
527 ProcessUnitOptionsUnion(ProcessUnitOptionsUnion&& u) FLATBUFFERS_NOEXCEPT :
528 type(ProcessUnitOptions_NONE), value(nullptr)
529 { std::swap(type, u.type); std::swap(value, u.value); }
530 ProcessUnitOptionsUnion(const ProcessUnitOptionsUnion &);
531 ProcessUnitOptionsUnion &operator=(const ProcessUnitOptionsUnion &u)
532 { ProcessUnitOptionsUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
533 ProcessUnitOptionsUnion &operator=(ProcessUnitOptionsUnion &&u) FLATBUFFERS_NOEXCEPT
534 { std::swap(type, u.type); std::swap(value, u.value); return *this; }
535 ~ProcessUnitOptionsUnion() { Reset(); }
536
537 void Reset();
538
539 template <typename T>
540 void Set(T&& val) {
541 typedef typename std::remove_reference<T>::type RT;
542 Reset();
543 type = ProcessUnitOptionsUnionTraits<RT>::enum_value;
544 if (type != ProcessUnitOptions_NONE) {
545 value = new RT(std::forward<T>(val));
546 }
547 }
548
549 static void *UnPack(const void *obj, ProcessUnitOptions type, const flatbuffers::resolver_function_t *resolver);
550 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
551
552 tflite::NormalizationOptionsT *AsNormalizationOptions() {
553 return type == ProcessUnitOptions_NormalizationOptions ?
554 reinterpret_cast<tflite::NormalizationOptionsT *>(value) : nullptr;
555 }
556 const tflite::NormalizationOptionsT *AsNormalizationOptions() const {
557 return type == ProcessUnitOptions_NormalizationOptions ?
558 reinterpret_cast<const tflite::NormalizationOptionsT *>(value) : nullptr;
559 }
560 tflite::ScoreCalibrationOptionsT *AsScoreCalibrationOptions() {
561 return type == ProcessUnitOptions_ScoreCalibrationOptions ?
562 reinterpret_cast<tflite::ScoreCalibrationOptionsT *>(value) : nullptr;
563 }
564 const tflite::ScoreCalibrationOptionsT *AsScoreCalibrationOptions() const {
565 return type == ProcessUnitOptions_ScoreCalibrationOptions ?
566 reinterpret_cast<const tflite::ScoreCalibrationOptionsT *>(value) : nullptr;
567 }
568 tflite::ScoreThresholdingOptionsT *AsScoreThresholdingOptions() {
569 return type == ProcessUnitOptions_ScoreThresholdingOptions ?
570 reinterpret_cast<tflite::ScoreThresholdingOptionsT *>(value) : nullptr;
571 }
572 const tflite::ScoreThresholdingOptionsT *AsScoreThresholdingOptions() const {
573 return type == ProcessUnitOptions_ScoreThresholdingOptions ?
574 reinterpret_cast<const tflite::ScoreThresholdingOptionsT *>(value) : nullptr;
575 }
576 tflite::BertTokenizerOptionsT *AsBertTokenizerOptions() {
577 return type == ProcessUnitOptions_BertTokenizerOptions ?
578 reinterpret_cast<tflite::BertTokenizerOptionsT *>(value) : nullptr;
579 }
580 const tflite::BertTokenizerOptionsT *AsBertTokenizerOptions() const {
581 return type == ProcessUnitOptions_BertTokenizerOptions ?
582 reinterpret_cast<const tflite::BertTokenizerOptionsT *>(value) : nullptr;
583 }
584 tflite::SentencePieceTokenizerOptionsT *AsSentencePieceTokenizerOptions() {
585 return type == ProcessUnitOptions_SentencePieceTokenizerOptions ?
586 reinterpret_cast<tflite::SentencePieceTokenizerOptionsT *>(value) : nullptr;
587 }
588 const tflite::SentencePieceTokenizerOptionsT *AsSentencePieceTokenizerOptions() const {
589 return type == ProcessUnitOptions_SentencePieceTokenizerOptions ?
590 reinterpret_cast<const tflite::SentencePieceTokenizerOptionsT *>(value) : nullptr;
591 }
592 tflite::RegexTokenizerOptionsT *AsRegexTokenizerOptions() {
593 return type == ProcessUnitOptions_RegexTokenizerOptions ?
594 reinterpret_cast<tflite::RegexTokenizerOptionsT *>(value) : nullptr;
595 }
596 const tflite::RegexTokenizerOptionsT *AsRegexTokenizerOptions() const {
597 return type == ProcessUnitOptions_RegexTokenizerOptions ?
598 reinterpret_cast<const tflite::RegexTokenizerOptionsT *>(value) : nullptr;
599 }
600 };
601
602 bool VerifyProcessUnitOptions(flatbuffers::Verifier &verifier, const void *obj, ProcessUnitOptions type);
603 bool VerifyProcessUnitOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
604
605 struct AssociatedFileT : public flatbuffers::NativeTable {
606 typedef AssociatedFile TableType;
607 std::string name{};
608 std::string description{};
609 tflite::AssociatedFileType type = tflite::AssociatedFileType_UNKNOWN;
610 std::string locale{};
611 std::string version{};
612 };
613
614 struct AssociatedFile FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
615 typedef AssociatedFileT NativeTableType;
616 typedef AssociatedFileBuilder Builder;
617 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
618 VT_NAME = 4,
619 VT_DESCRIPTION = 6,
620 VT_TYPE = 8,
621 VT_LOCALE = 10,
622 VT_VERSION = 12
623 };
624 const flatbuffers::String *name() const {
625 return GetPointer<const flatbuffers::String *>(VT_NAME);
626 }
627 const flatbuffers::String *description() const {
628 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
629 }
630 tflite::AssociatedFileType type() const {
631 return static_cast<tflite::AssociatedFileType>(GetField<int8_t>(VT_TYPE, 0));
632 }
633 const flatbuffers::String *locale() const {
634 return GetPointer<const flatbuffers::String *>(VT_LOCALE);
635 }
636 const flatbuffers::String *version() const {
637 return GetPointer<const flatbuffers::String *>(VT_VERSION);
638 }
639 bool Verify(flatbuffers::Verifier &verifier) const {
640 return VerifyTableStart(verifier) &&
641 VerifyOffset(verifier, VT_NAME) &&
642 verifier.VerifyString(name()) &&
643 VerifyOffset(verifier, VT_DESCRIPTION) &&
644 verifier.VerifyString(description()) &&
645 VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
646 VerifyOffset(verifier, VT_LOCALE) &&
647 verifier.VerifyString(locale()) &&
648 VerifyOffset(verifier, VT_VERSION) &&
649 verifier.VerifyString(version()) &&
650 verifier.EndTable();
651 }
652 AssociatedFileT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
653 void UnPackTo(AssociatedFileT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
654 static flatbuffers::Offset<AssociatedFile> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssociatedFileT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
655 };
656
657 struct AssociatedFileBuilder {
658 typedef AssociatedFile Table;
659 flatbuffers::FlatBufferBuilder &fbb_;
660 flatbuffers::uoffset_t start_;
661 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
662 fbb_.AddOffset(AssociatedFile::VT_NAME, name);
663 }
664 void add_description(flatbuffers::Offset<flatbuffers::String> description) {
665 fbb_.AddOffset(AssociatedFile::VT_DESCRIPTION, description);
666 }
667 void add_type(tflite::AssociatedFileType type) {
668 fbb_.AddElement<int8_t>(AssociatedFile::VT_TYPE, static_cast<int8_t>(type), 0);
669 }
670 void add_locale(flatbuffers::Offset<flatbuffers::String> locale) {
671 fbb_.AddOffset(AssociatedFile::VT_LOCALE, locale);
672 }
673 void add_version(flatbuffers::Offset<flatbuffers::String> version) {
674 fbb_.AddOffset(AssociatedFile::VT_VERSION, version);
675 }
676 explicit AssociatedFileBuilder(flatbuffers::FlatBufferBuilder &_fbb)
677 : fbb_(_fbb) {
678 start_ = fbb_.StartTable();
679 }
680 flatbuffers::Offset<AssociatedFile> Finish() {
681 const auto end = fbb_.EndTable(start_);
682 auto o = flatbuffers::Offset<AssociatedFile>(end);
683 return o;
684 }
685 };
686
687 inline flatbuffers::Offset<AssociatedFile> CreateAssociatedFile(
688 flatbuffers::FlatBufferBuilder &_fbb,
689 flatbuffers::Offset<flatbuffers::String> name = 0,
690 flatbuffers::Offset<flatbuffers::String> description = 0,
691 tflite::AssociatedFileType type = tflite::AssociatedFileType_UNKNOWN,
692 flatbuffers::Offset<flatbuffers::String> locale = 0,
693 flatbuffers::Offset<flatbuffers::String> version = 0) {
694 AssociatedFileBuilder builder_(_fbb);
695 builder_.add_version(version);
696 builder_.add_locale(locale);
697 builder_.add_description(description);
698 builder_.add_name(name);
699 builder_.add_type(type);
700 return builder_.Finish();
701 }
702
703 inline flatbuffers::Offset<AssociatedFile> CreateAssociatedFileDirect(
704 flatbuffers::FlatBufferBuilder &_fbb,
705 const char *name = nullptr,
706 const char *description = nullptr,
707 tflite::AssociatedFileType type = tflite::AssociatedFileType_UNKNOWN,
708 const char *locale = nullptr,
709 const char *version = nullptr) {
710 auto name__ = name ? _fbb.CreateString(name) : 0;
711 auto description__ = description ? _fbb.CreateString(description) : 0;
712 auto locale__ = locale ? _fbb.CreateString(locale) : 0;
713 auto version__ = version ? _fbb.CreateString(version) : 0;
714 return tflite::CreateAssociatedFile(
715 _fbb,
716 name__,
717 description__,
718 type,
719 locale__,
720 version__);
721 }
722
723 flatbuffers::Offset<AssociatedFile> CreateAssociatedFile(flatbuffers::FlatBufferBuilder &_fbb, const AssociatedFileT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
724
725 struct FeaturePropertiesT : public flatbuffers::NativeTable {
726 typedef FeatureProperties TableType;
727 };
728
729 struct FeatureProperties FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
730 typedef FeaturePropertiesT NativeTableType;
731 typedef FeaturePropertiesBuilder Builder;
732 bool Verify(flatbuffers::Verifier &verifier) const {
733 return VerifyTableStart(verifier) &&
734 verifier.EndTable();
735 }
736 FeaturePropertiesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
737 void UnPackTo(FeaturePropertiesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
738 static flatbuffers::Offset<FeatureProperties> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FeaturePropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
739 };
740
741 struct FeaturePropertiesBuilder {
742 typedef FeatureProperties Table;
743 flatbuffers::FlatBufferBuilder &fbb_;
744 flatbuffers::uoffset_t start_;
745 explicit FeaturePropertiesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
746 : fbb_(_fbb) {
747 start_ = fbb_.StartTable();
748 }
749 flatbuffers::Offset<FeatureProperties> Finish() {
750 const auto end = fbb_.EndTable(start_);
751 auto o = flatbuffers::Offset<FeatureProperties>(end);
752 return o;
753 }
754 };
755
756 inline flatbuffers::Offset<FeatureProperties> CreateFeatureProperties(
757 flatbuffers::FlatBufferBuilder &_fbb) {
758 FeaturePropertiesBuilder builder_(_fbb);
759 return builder_.Finish();
760 }
761
762 flatbuffers::Offset<FeatureProperties> CreateFeatureProperties(flatbuffers::FlatBufferBuilder &_fbb, const FeaturePropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
763
764 struct ImageSizeT : public flatbuffers::NativeTable {
765 typedef ImageSize TableType;
766 uint32_t width = 0;
767 uint32_t height = 0;
768 };
769
770 struct ImageSize FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
771 typedef ImageSizeT NativeTableType;
772 typedef ImageSizeBuilder Builder;
773 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
774 VT_WIDTH = 4,
775 VT_HEIGHT = 6
776 };
777 uint32_t width() const {
778 return GetField<uint32_t>(VT_WIDTH, 0);
779 }
780 uint32_t height() const {
781 return GetField<uint32_t>(VT_HEIGHT, 0);
782 }
783 bool Verify(flatbuffers::Verifier &verifier) const {
784 return VerifyTableStart(verifier) &&
785 VerifyField<uint32_t>(verifier, VT_WIDTH, 4) &&
786 VerifyField<uint32_t>(verifier, VT_HEIGHT, 4) &&
787 verifier.EndTable();
788 }
789 ImageSizeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
790 void UnPackTo(ImageSizeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
791 static flatbuffers::Offset<ImageSize> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ImageSizeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
792 };
793
794 struct ImageSizeBuilder {
795 typedef ImageSize Table;
796 flatbuffers::FlatBufferBuilder &fbb_;
797 flatbuffers::uoffset_t start_;
798 void add_width(uint32_t width) {
799 fbb_.AddElement<uint32_t>(ImageSize::VT_WIDTH, width, 0);
800 }
801 void add_height(uint32_t height) {
802 fbb_.AddElement<uint32_t>(ImageSize::VT_HEIGHT, height, 0);
803 }
804 explicit ImageSizeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
805 : fbb_(_fbb) {
806 start_ = fbb_.StartTable();
807 }
808 flatbuffers::Offset<ImageSize> Finish() {
809 const auto end = fbb_.EndTable(start_);
810 auto o = flatbuffers::Offset<ImageSize>(end);
811 return o;
812 }
813 };
814
815 inline flatbuffers::Offset<ImageSize> CreateImageSize(
816 flatbuffers::FlatBufferBuilder &_fbb,
817 uint32_t width = 0,
818 uint32_t height = 0) {
819 ImageSizeBuilder builder_(_fbb);
820 builder_.add_height(height);
821 builder_.add_width(width);
822 return builder_.Finish();
823 }
824
825 flatbuffers::Offset<ImageSize> CreateImageSize(flatbuffers::FlatBufferBuilder &_fbb, const ImageSizeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
826
827 struct ImagePropertiesT : public flatbuffers::NativeTable {
828 typedef ImageProperties TableType;
829 tflite::ColorSpaceType color_space = tflite::ColorSpaceType_UNKNOWN;
830 std::unique_ptr<tflite::ImageSizeT> default_size{};
831 ImagePropertiesT() = default;
832 ImagePropertiesT(const ImagePropertiesT &o);
833 ImagePropertiesT(ImagePropertiesT&&) FLATBUFFERS_NOEXCEPT = default;
834 ImagePropertiesT &operator=(ImagePropertiesT o) FLATBUFFERS_NOEXCEPT;
835 };
836
837 struct ImageProperties FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
838 typedef ImagePropertiesT NativeTableType;
839 typedef ImagePropertiesBuilder Builder;
840 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
841 VT_COLOR_SPACE = 4,
842 VT_DEFAULT_SIZE = 6
843 };
844 tflite::ColorSpaceType color_space() const {
845 return static_cast<tflite::ColorSpaceType>(GetField<int8_t>(VT_COLOR_SPACE, 0));
846 }
847 const tflite::ImageSize *default_size() const {
848 return GetPointer<const tflite::ImageSize *>(VT_DEFAULT_SIZE);
849 }
850 bool Verify(flatbuffers::Verifier &verifier) const {
851 return VerifyTableStart(verifier) &&
852 VerifyField<int8_t>(verifier, VT_COLOR_SPACE, 1) &&
853 VerifyOffset(verifier, VT_DEFAULT_SIZE) &&
854 verifier.VerifyTable(default_size()) &&
855 verifier.EndTable();
856 }
857 ImagePropertiesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
858 void UnPackTo(ImagePropertiesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
859 static flatbuffers::Offset<ImageProperties> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ImagePropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
860 };
861
862 struct ImagePropertiesBuilder {
863 typedef ImageProperties Table;
864 flatbuffers::FlatBufferBuilder &fbb_;
865 flatbuffers::uoffset_t start_;
866 void add_color_space(tflite::ColorSpaceType color_space) {
867 fbb_.AddElement<int8_t>(ImageProperties::VT_COLOR_SPACE, static_cast<int8_t>(color_space), 0);
868 }
869 void add_default_size(flatbuffers::Offset<tflite::ImageSize> default_size) {
870 fbb_.AddOffset(ImageProperties::VT_DEFAULT_SIZE, default_size);
871 }
872 explicit ImagePropertiesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
873 : fbb_(_fbb) {
874 start_ = fbb_.StartTable();
875 }
876 flatbuffers::Offset<ImageProperties> Finish() {
877 const auto end = fbb_.EndTable(start_);
878 auto o = flatbuffers::Offset<ImageProperties>(end);
879 return o;
880 }
881 };
882
883 inline flatbuffers::Offset<ImageProperties> CreateImageProperties(
884 flatbuffers::FlatBufferBuilder &_fbb,
885 tflite::ColorSpaceType color_space = tflite::ColorSpaceType_UNKNOWN,
886 flatbuffers::Offset<tflite::ImageSize> default_size = 0) {
887 ImagePropertiesBuilder builder_(_fbb);
888 builder_.add_default_size(default_size);
889 builder_.add_color_space(color_space);
890 return builder_.Finish();
891 }
892
893 flatbuffers::Offset<ImageProperties> CreateImageProperties(flatbuffers::FlatBufferBuilder &_fbb, const ImagePropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
894
895 struct AudioPropertiesT : public flatbuffers::NativeTable {
896 typedef AudioProperties TableType;
897 uint32_t sample_rate = 0;
898 uint32_t channels = 0;
899 };
900
901 struct AudioProperties FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
902 typedef AudioPropertiesT NativeTableType;
903 typedef AudioPropertiesBuilder Builder;
904 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
905 VT_SAMPLE_RATE = 4,
906 VT_CHANNELS = 6
907 };
908 uint32_t sample_rate() const {
909 return GetField<uint32_t>(VT_SAMPLE_RATE, 0);
910 }
911 uint32_t channels() const {
912 return GetField<uint32_t>(VT_CHANNELS, 0);
913 }
914 bool Verify(flatbuffers::Verifier &verifier) const {
915 return VerifyTableStart(verifier) &&
916 VerifyField<uint32_t>(verifier, VT_SAMPLE_RATE, 4) &&
917 VerifyField<uint32_t>(verifier, VT_CHANNELS, 4) &&
918 verifier.EndTable();
919 }
920 AudioPropertiesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
921 void UnPackTo(AudioPropertiesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
922 static flatbuffers::Offset<AudioProperties> Pack(flatbuffers::FlatBufferBuilder &_fbb, const AudioPropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
923 };
924
925 struct AudioPropertiesBuilder {
926 typedef AudioProperties Table;
927 flatbuffers::FlatBufferBuilder &fbb_;
928 flatbuffers::uoffset_t start_;
929 void add_sample_rate(uint32_t sample_rate) {
930 fbb_.AddElement<uint32_t>(AudioProperties::VT_SAMPLE_RATE, sample_rate, 0);
931 }
932 void add_channels(uint32_t channels) {
933 fbb_.AddElement<uint32_t>(AudioProperties::VT_CHANNELS, channels, 0);
934 }
935 explicit AudioPropertiesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
936 : fbb_(_fbb) {
937 start_ = fbb_.StartTable();
938 }
939 flatbuffers::Offset<AudioProperties> Finish() {
940 const auto end = fbb_.EndTable(start_);
941 auto o = flatbuffers::Offset<AudioProperties>(end);
942 return o;
943 }
944 };
945
946 inline flatbuffers::Offset<AudioProperties> CreateAudioProperties(
947 flatbuffers::FlatBufferBuilder &_fbb,
948 uint32_t sample_rate = 0,
949 uint32_t channels = 0) {
950 AudioPropertiesBuilder builder_(_fbb);
951 builder_.add_channels(channels);
952 builder_.add_sample_rate(sample_rate);
953 return builder_.Finish();
954 }
955
956 flatbuffers::Offset<AudioProperties> CreateAudioProperties(flatbuffers::FlatBufferBuilder &_fbb, const AudioPropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
957
958 struct BoundingBoxPropertiesT : public flatbuffers::NativeTable {
959 typedef BoundingBoxProperties TableType;
960 std::vector<uint32_t> index{};
961 tflite::BoundingBoxType type = tflite::BoundingBoxType_UNKNOWN;
962 tflite::CoordinateType coordinate_type = tflite::CoordinateType_RATIO;
963 };
964
965 struct BoundingBoxProperties FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
966 typedef BoundingBoxPropertiesT NativeTableType;
967 typedef BoundingBoxPropertiesBuilder Builder;
968 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
969 VT_INDEX = 4,
970 VT_TYPE = 6,
971 VT_COORDINATE_TYPE = 8
972 };
973 const flatbuffers::Vector<uint32_t> *index() const {
974 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_INDEX);
975 }
976 tflite::BoundingBoxType type() const {
977 return static_cast<tflite::BoundingBoxType>(GetField<int8_t>(VT_TYPE, 0));
978 }
979 tflite::CoordinateType coordinate_type() const {
980 return static_cast<tflite::CoordinateType>(GetField<int8_t>(VT_COORDINATE_TYPE, 0));
981 }
982 bool Verify(flatbuffers::Verifier &verifier) const {
983 return VerifyTableStart(verifier) &&
984 VerifyOffset(verifier, VT_INDEX) &&
985 verifier.VerifyVector(index()) &&
986 VerifyField<int8_t>(verifier, VT_TYPE, 1) &&
987 VerifyField<int8_t>(verifier, VT_COORDINATE_TYPE, 1) &&
988 verifier.EndTable();
989 }
990 BoundingBoxPropertiesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
991 void UnPackTo(BoundingBoxPropertiesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
992 static flatbuffers::Offset<BoundingBoxProperties> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BoundingBoxPropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
993 };
994
995 struct BoundingBoxPropertiesBuilder {
996 typedef BoundingBoxProperties Table;
997 flatbuffers::FlatBufferBuilder &fbb_;
998 flatbuffers::uoffset_t start_;
999 void add_index(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> index) {
1000 fbb_.AddOffset(BoundingBoxProperties::VT_INDEX, index);
1001 }
1002 void add_type(tflite::BoundingBoxType type) {
1003 fbb_.AddElement<int8_t>(BoundingBoxProperties::VT_TYPE, static_cast<int8_t>(type), 0);
1004 }
1005 void add_coordinate_type(tflite::CoordinateType coordinate_type) {
1006 fbb_.AddElement<int8_t>(BoundingBoxProperties::VT_COORDINATE_TYPE, static_cast<int8_t>(coordinate_type), 0);
1007 }
1008 explicit BoundingBoxPropertiesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1009 : fbb_(_fbb) {
1010 start_ = fbb_.StartTable();
1011 }
1012 flatbuffers::Offset<BoundingBoxProperties> Finish() {
1013 const auto end = fbb_.EndTable(start_);
1014 auto o = flatbuffers::Offset<BoundingBoxProperties>(end);
1015 return o;
1016 }
1017 };
1018
1019 inline flatbuffers::Offset<BoundingBoxProperties> CreateBoundingBoxProperties(
1020 flatbuffers::FlatBufferBuilder &_fbb,
1021 flatbuffers::Offset<flatbuffers::Vector<uint32_t>> index = 0,
1022 tflite::BoundingBoxType type = tflite::BoundingBoxType_UNKNOWN,
1023 tflite::CoordinateType coordinate_type = tflite::CoordinateType_RATIO) {
1024 BoundingBoxPropertiesBuilder builder_(_fbb);
1025 builder_.add_index(index);
1026 builder_.add_coordinate_type(coordinate_type);
1027 builder_.add_type(type);
1028 return builder_.Finish();
1029 }
1030
1031 inline flatbuffers::Offset<BoundingBoxProperties> CreateBoundingBoxPropertiesDirect(
1032 flatbuffers::FlatBufferBuilder &_fbb,
1033 const std::vector<uint32_t> *index = nullptr,
1034 tflite::BoundingBoxType type = tflite::BoundingBoxType_UNKNOWN,
1035 tflite::CoordinateType coordinate_type = tflite::CoordinateType_RATIO) {
1036 auto index__ = index ? _fbb.CreateVector<uint32_t>(*index) : 0;
1037 return tflite::CreateBoundingBoxProperties(
1038 _fbb,
1039 index__,
1040 type,
1041 coordinate_type);
1042 }
1043
1044 flatbuffers::Offset<BoundingBoxProperties> CreateBoundingBoxProperties(flatbuffers::FlatBufferBuilder &_fbb, const BoundingBoxPropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1045
1046 struct ValueRangeT : public flatbuffers::NativeTable {
1047 typedef ValueRange TableType;
1048 int32_t min = 0;
1049 int32_t max = 0;
1050 };
1051
1052 struct ValueRange FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1053 typedef ValueRangeT NativeTableType;
1054 typedef ValueRangeBuilder Builder;
1055 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1056 VT_MIN = 4,
1057 VT_MAX = 6
1058 };
1059 int32_t min() const {
1060 return GetField<int32_t>(VT_MIN, 0);
1061 }
1062 int32_t max() const {
1063 return GetField<int32_t>(VT_MAX, 0);
1064 }
1065 bool Verify(flatbuffers::Verifier &verifier) const {
1066 return VerifyTableStart(verifier) &&
1067 VerifyField<int32_t>(verifier, VT_MIN, 4) &&
1068 VerifyField<int32_t>(verifier, VT_MAX, 4) &&
1069 verifier.EndTable();
1070 }
1071 ValueRangeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1072 void UnPackTo(ValueRangeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1073 static flatbuffers::Offset<ValueRange> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ValueRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1074 };
1075
1076 struct ValueRangeBuilder {
1077 typedef ValueRange Table;
1078 flatbuffers::FlatBufferBuilder &fbb_;
1079 flatbuffers::uoffset_t start_;
1080 void add_min(int32_t min) {
1081 fbb_.AddElement<int32_t>(ValueRange::VT_MIN, min, 0);
1082 }
1083 void add_max(int32_t max) {
1084 fbb_.AddElement<int32_t>(ValueRange::VT_MAX, max, 0);
1085 }
1086 explicit ValueRangeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1087 : fbb_(_fbb) {
1088 start_ = fbb_.StartTable();
1089 }
1090 flatbuffers::Offset<ValueRange> Finish() {
1091 const auto end = fbb_.EndTable(start_);
1092 auto o = flatbuffers::Offset<ValueRange>(end);
1093 return o;
1094 }
1095 };
1096
1097 inline flatbuffers::Offset<ValueRange> CreateValueRange(
1098 flatbuffers::FlatBufferBuilder &_fbb,
1099 int32_t min = 0,
1100 int32_t max = 0) {
1101 ValueRangeBuilder builder_(_fbb);
1102 builder_.add_max(max);
1103 builder_.add_min(min);
1104 return builder_.Finish();
1105 }
1106
1107 flatbuffers::Offset<ValueRange> CreateValueRange(flatbuffers::FlatBufferBuilder &_fbb, const ValueRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1108
1109 struct ContentT : public flatbuffers::NativeTable {
1110 typedef Content TableType;
1111 tflite::ContentPropertiesUnion content_properties{};
1112 std::unique_ptr<tflite::ValueRangeT> range{};
1113 ContentT() = default;
1114 ContentT(const ContentT &o);
1115 ContentT(ContentT&&) FLATBUFFERS_NOEXCEPT = default;
1116 ContentT &operator=(ContentT o) FLATBUFFERS_NOEXCEPT;
1117 };
1118
1119 struct Content FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1120 typedef ContentT NativeTableType;
1121 typedef ContentBuilder Builder;
1122 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1123 VT_CONTENT_PROPERTIES_TYPE = 4,
1124 VT_CONTENT_PROPERTIES = 6,
1125 VT_RANGE = 8
1126 };
1127 tflite::ContentProperties content_properties_type() const {
1128 return static_cast<tflite::ContentProperties>(GetField<uint8_t>(VT_CONTENT_PROPERTIES_TYPE, 0));
1129 }
1130 const void *content_properties() const {
1131 return GetPointer<const void *>(VT_CONTENT_PROPERTIES);
1132 }
1133 template<typename T> const T *content_properties_as() const;
1134 const tflite::FeatureProperties *content_properties_as_FeatureProperties() const {
1135 return content_properties_type() == tflite::ContentProperties_FeatureProperties ? static_cast<const tflite::FeatureProperties *>(content_properties()) : nullptr;
1136 }
1137 const tflite::ImageProperties *content_properties_as_ImageProperties() const {
1138 return content_properties_type() == tflite::ContentProperties_ImageProperties ? static_cast<const tflite::ImageProperties *>(content_properties()) : nullptr;
1139 }
1140 const tflite::BoundingBoxProperties *content_properties_as_BoundingBoxProperties() const {
1141 return content_properties_type() == tflite::ContentProperties_BoundingBoxProperties ? static_cast<const tflite::BoundingBoxProperties *>(content_properties()) : nullptr;
1142 }
1143 const tflite::AudioProperties *content_properties_as_AudioProperties() const {
1144 return content_properties_type() == tflite::ContentProperties_AudioProperties ? static_cast<const tflite::AudioProperties *>(content_properties()) : nullptr;
1145 }
1146 const tflite::ValueRange *range() const {
1147 return GetPointer<const tflite::ValueRange *>(VT_RANGE);
1148 }
1149 bool Verify(flatbuffers::Verifier &verifier) const {
1150 return VerifyTableStart(verifier) &&
1151 VerifyField<uint8_t>(verifier, VT_CONTENT_PROPERTIES_TYPE, 1) &&
1152 VerifyOffset(verifier, VT_CONTENT_PROPERTIES) &&
1153 VerifyContentProperties(verifier, content_properties(), content_properties_type()) &&
1154 VerifyOffset(verifier, VT_RANGE) &&
1155 verifier.VerifyTable(range()) &&
1156 verifier.EndTable();
1157 }
1158 ContentT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1159 void UnPackTo(ContentT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1160 static flatbuffers::Offset<Content> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ContentT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1161 };
1162
1163 template<> inline const tflite::FeatureProperties *Content::content_properties_as<tflite::FeatureProperties>() const {
1164 return content_properties_as_FeatureProperties();
1165 }
1166
1167 template<> inline const tflite::ImageProperties *Content::content_properties_as<tflite::ImageProperties>() const {
1168 return content_properties_as_ImageProperties();
1169 }
1170
1171 template<> inline const tflite::BoundingBoxProperties *Content::content_properties_as<tflite::BoundingBoxProperties>() const {
1172 return content_properties_as_BoundingBoxProperties();
1173 }
1174
1175 template<> inline const tflite::AudioProperties *Content::content_properties_as<tflite::AudioProperties>() const {
1176 return content_properties_as_AudioProperties();
1177 }
1178
1179 struct ContentBuilder {
1180 typedef Content Table;
1181 flatbuffers::FlatBufferBuilder &fbb_;
1182 flatbuffers::uoffset_t start_;
1183 void add_content_properties_type(tflite::ContentProperties content_properties_type) {
1184 fbb_.AddElement<uint8_t>(Content::VT_CONTENT_PROPERTIES_TYPE, static_cast<uint8_t>(content_properties_type), 0);
1185 }
1186 void add_content_properties(flatbuffers::Offset<void> content_properties) {
1187 fbb_.AddOffset(Content::VT_CONTENT_PROPERTIES, content_properties);
1188 }
1189 void add_range(flatbuffers::Offset<tflite::ValueRange> range) {
1190 fbb_.AddOffset(Content::VT_RANGE, range);
1191 }
1192 explicit ContentBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1193 : fbb_(_fbb) {
1194 start_ = fbb_.StartTable();
1195 }
1196 flatbuffers::Offset<Content> Finish() {
1197 const auto end = fbb_.EndTable(start_);
1198 auto o = flatbuffers::Offset<Content>(end);
1199 return o;
1200 }
1201 };
1202
1203 inline flatbuffers::Offset<Content> CreateContent(
1204 flatbuffers::FlatBufferBuilder &_fbb,
1205 tflite::ContentProperties content_properties_type = tflite::ContentProperties_NONE,
1206 flatbuffers::Offset<void> content_properties = 0,
1207 flatbuffers::Offset<tflite::ValueRange> range = 0) {
1208 ContentBuilder builder_(_fbb);
1209 builder_.add_range(range);
1210 builder_.add_content_properties(content_properties);
1211 builder_.add_content_properties_type(content_properties_type);
1212 return builder_.Finish();
1213 }
1214
1215 flatbuffers::Offset<Content> CreateContent(flatbuffers::FlatBufferBuilder &_fbb, const ContentT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1216
1217 struct NormalizationOptionsT : public flatbuffers::NativeTable {
1218 typedef NormalizationOptions TableType;
1219 std::vector<float> mean{};
1220 std::vector<float> std{};
1221 };
1222
1223 struct NormalizationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1224 typedef NormalizationOptionsT NativeTableType;
1225 typedef NormalizationOptionsBuilder Builder;
1226 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1227 VT_MEAN = 4,
1228 VT_STD = 6
1229 };
1230 const flatbuffers::Vector<float> *mean() const {
1231 return GetPointer<const flatbuffers::Vector<float> *>(VT_MEAN);
1232 }
1233 const flatbuffers::Vector<float> *std() const {
1234 return GetPointer<const flatbuffers::Vector<float> *>(VT_STD);
1235 }
1236 bool Verify(flatbuffers::Verifier &verifier) const {
1237 return VerifyTableStart(verifier) &&
1238 VerifyOffset(verifier, VT_MEAN) &&
1239 verifier.VerifyVector(mean()) &&
1240 VerifyOffset(verifier, VT_STD) &&
1241 verifier.VerifyVector(std()) &&
1242 verifier.EndTable();
1243 }
1244 NormalizationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1245 void UnPackTo(NormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1246 static flatbuffers::Offset<NormalizationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1247 };
1248
1249 struct NormalizationOptionsBuilder {
1250 typedef NormalizationOptions Table;
1251 flatbuffers::FlatBufferBuilder &fbb_;
1252 flatbuffers::uoffset_t start_;
1253 void add_mean(flatbuffers::Offset<flatbuffers::Vector<float>> mean) {
1254 fbb_.AddOffset(NormalizationOptions::VT_MEAN, mean);
1255 }
1256 void add_std(flatbuffers::Offset<flatbuffers::Vector<float>> std) {
1257 fbb_.AddOffset(NormalizationOptions::VT_STD, std);
1258 }
1259 explicit NormalizationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1260 : fbb_(_fbb) {
1261 start_ = fbb_.StartTable();
1262 }
1263 flatbuffers::Offset<NormalizationOptions> Finish() {
1264 const auto end = fbb_.EndTable(start_);
1265 auto o = flatbuffers::Offset<NormalizationOptions>(end);
1266 return o;
1267 }
1268 };
1269
1270 inline flatbuffers::Offset<NormalizationOptions> CreateNormalizationOptions(
1271 flatbuffers::FlatBufferBuilder &_fbb,
1272 flatbuffers::Offset<flatbuffers::Vector<float>> mean = 0,
1273 flatbuffers::Offset<flatbuffers::Vector<float>> std = 0) {
1274 NormalizationOptionsBuilder builder_(_fbb);
1275 builder_.add_std(std);
1276 builder_.add_mean(mean);
1277 return builder_.Finish();
1278 }
1279
1280 inline flatbuffers::Offset<NormalizationOptions> CreateNormalizationOptionsDirect(
1281 flatbuffers::FlatBufferBuilder &_fbb,
1282 const std::vector<float> *mean = nullptr,
1283 const std::vector<float> *std = nullptr) {
1284 auto mean__ = mean ? _fbb.CreateVector<float>(*mean) : 0;
1285 auto std__ = std ? _fbb.CreateVector<float>(*std) : 0;
1286 return tflite::CreateNormalizationOptions(
1287 _fbb,
1288 mean__,
1289 std__);
1290 }
1291
1292 flatbuffers::Offset<NormalizationOptions> CreateNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const NormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1293
1294 struct ScoreCalibrationOptionsT : public flatbuffers::NativeTable {
1295 typedef ScoreCalibrationOptions TableType;
1296 tflite::ScoreTransformationType score_transformation = tflite::ScoreTransformationType_IDENTITY;
1297 float default_score = 0.0f;
1298 };
1299
1300 struct ScoreCalibrationOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1301 typedef ScoreCalibrationOptionsT NativeTableType;
1302 typedef ScoreCalibrationOptionsBuilder Builder;
1303 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1304 VT_SCORE_TRANSFORMATION = 4,
1305 VT_DEFAULT_SCORE = 6
1306 };
1307 tflite::ScoreTransformationType score_transformation() const {
1308 return static_cast<tflite::ScoreTransformationType>(GetField<int8_t>(VT_SCORE_TRANSFORMATION, 0));
1309 }
1310 float default_score() const {
1311 return GetField<float>(VT_DEFAULT_SCORE, 0.0f);
1312 }
1313 bool Verify(flatbuffers::Verifier &verifier) const {
1314 return VerifyTableStart(verifier) &&
1315 VerifyField<int8_t>(verifier, VT_SCORE_TRANSFORMATION, 1) &&
1316 VerifyField<float>(verifier, VT_DEFAULT_SCORE, 4) &&
1317 verifier.EndTable();
1318 }
1319 ScoreCalibrationOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1320 void UnPackTo(ScoreCalibrationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1321 static flatbuffers::Offset<ScoreCalibrationOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScoreCalibrationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1322 };
1323
1324 struct ScoreCalibrationOptionsBuilder {
1325 typedef ScoreCalibrationOptions Table;
1326 flatbuffers::FlatBufferBuilder &fbb_;
1327 flatbuffers::uoffset_t start_;
1328 void add_score_transformation(tflite::ScoreTransformationType score_transformation) {
1329 fbb_.AddElement<int8_t>(ScoreCalibrationOptions::VT_SCORE_TRANSFORMATION, static_cast<int8_t>(score_transformation), 0);
1330 }
1331 void add_default_score(float default_score) {
1332 fbb_.AddElement<float>(ScoreCalibrationOptions::VT_DEFAULT_SCORE, default_score, 0.0f);
1333 }
1334 explicit ScoreCalibrationOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1335 : fbb_(_fbb) {
1336 start_ = fbb_.StartTable();
1337 }
1338 flatbuffers::Offset<ScoreCalibrationOptions> Finish() {
1339 const auto end = fbb_.EndTable(start_);
1340 auto o = flatbuffers::Offset<ScoreCalibrationOptions>(end);
1341 return o;
1342 }
1343 };
1344
1345 inline flatbuffers::Offset<ScoreCalibrationOptions> CreateScoreCalibrationOptions(
1346 flatbuffers::FlatBufferBuilder &_fbb,
1347 tflite::ScoreTransformationType score_transformation = tflite::ScoreTransformationType_IDENTITY,
1348 float default_score = 0.0f) {
1349 ScoreCalibrationOptionsBuilder builder_(_fbb);
1350 builder_.add_default_score(default_score);
1351 builder_.add_score_transformation(score_transformation);
1352 return builder_.Finish();
1353 }
1354
1355 flatbuffers::Offset<ScoreCalibrationOptions> CreateScoreCalibrationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScoreCalibrationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1356
1357 struct ScoreThresholdingOptionsT : public flatbuffers::NativeTable {
1358 typedef ScoreThresholdingOptions TableType;
1359 float global_score_threshold = 0.0f;
1360 };
1361
1362 struct ScoreThresholdingOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1363 typedef ScoreThresholdingOptionsT NativeTableType;
1364 typedef ScoreThresholdingOptionsBuilder Builder;
1365 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1366 VT_GLOBAL_SCORE_THRESHOLD = 4
1367 };
1368 float global_score_threshold() const {
1369 return GetField<float>(VT_GLOBAL_SCORE_THRESHOLD, 0.0f);
1370 }
1371 bool Verify(flatbuffers::Verifier &verifier) const {
1372 return VerifyTableStart(verifier) &&
1373 VerifyField<float>(verifier, VT_GLOBAL_SCORE_THRESHOLD, 4) &&
1374 verifier.EndTable();
1375 }
1376 ScoreThresholdingOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1377 void UnPackTo(ScoreThresholdingOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1378 static flatbuffers::Offset<ScoreThresholdingOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScoreThresholdingOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1379 };
1380
1381 struct ScoreThresholdingOptionsBuilder {
1382 typedef ScoreThresholdingOptions Table;
1383 flatbuffers::FlatBufferBuilder &fbb_;
1384 flatbuffers::uoffset_t start_;
1385 void add_global_score_threshold(float global_score_threshold) {
1386 fbb_.AddElement<float>(ScoreThresholdingOptions::VT_GLOBAL_SCORE_THRESHOLD, global_score_threshold, 0.0f);
1387 }
1388 explicit ScoreThresholdingOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1389 : fbb_(_fbb) {
1390 start_ = fbb_.StartTable();
1391 }
1392 flatbuffers::Offset<ScoreThresholdingOptions> Finish() {
1393 const auto end = fbb_.EndTable(start_);
1394 auto o = flatbuffers::Offset<ScoreThresholdingOptions>(end);
1395 return o;
1396 }
1397 };
1398
1399 inline flatbuffers::Offset<ScoreThresholdingOptions> CreateScoreThresholdingOptions(
1400 flatbuffers::FlatBufferBuilder &_fbb,
1401 float global_score_threshold = 0.0f) {
1402 ScoreThresholdingOptionsBuilder builder_(_fbb);
1403 builder_.add_global_score_threshold(global_score_threshold);
1404 return builder_.Finish();
1405 }
1406
1407 flatbuffers::Offset<ScoreThresholdingOptions> CreateScoreThresholdingOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScoreThresholdingOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1408
1409 struct BertTokenizerOptionsT : public flatbuffers::NativeTable {
1410 typedef BertTokenizerOptions TableType;
1411 std::vector<std::unique_ptr<tflite::AssociatedFileT>> vocab_file{};
1412 BertTokenizerOptionsT() = default;
1413 BertTokenizerOptionsT(const BertTokenizerOptionsT &o);
1414 BertTokenizerOptionsT(BertTokenizerOptionsT&&) FLATBUFFERS_NOEXCEPT = default;
1415 BertTokenizerOptionsT &operator=(BertTokenizerOptionsT o) FLATBUFFERS_NOEXCEPT;
1416 };
1417
1418 struct BertTokenizerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1419 typedef BertTokenizerOptionsT NativeTableType;
1420 typedef BertTokenizerOptionsBuilder Builder;
1421 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1422 VT_VOCAB_FILE = 4
1423 };
1424 const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *vocab_file() const {
1425 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *>(VT_VOCAB_FILE);
1426 }
1427 bool Verify(flatbuffers::Verifier &verifier) const {
1428 return VerifyTableStart(verifier) &&
1429 VerifyOffset(verifier, VT_VOCAB_FILE) &&
1430 verifier.VerifyVector(vocab_file()) &&
1431 verifier.VerifyVectorOfTables(vocab_file()) &&
1432 verifier.EndTable();
1433 }
1434 BertTokenizerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1435 void UnPackTo(BertTokenizerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1436 static flatbuffers::Offset<BertTokenizerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const BertTokenizerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1437 };
1438
1439 struct BertTokenizerOptionsBuilder {
1440 typedef BertTokenizerOptions Table;
1441 flatbuffers::FlatBufferBuilder &fbb_;
1442 flatbuffers::uoffset_t start_;
1443 void add_vocab_file(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> vocab_file) {
1444 fbb_.AddOffset(BertTokenizerOptions::VT_VOCAB_FILE, vocab_file);
1445 }
1446 explicit BertTokenizerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1447 : fbb_(_fbb) {
1448 start_ = fbb_.StartTable();
1449 }
1450 flatbuffers::Offset<BertTokenizerOptions> Finish() {
1451 const auto end = fbb_.EndTable(start_);
1452 auto o = flatbuffers::Offset<BertTokenizerOptions>(end);
1453 return o;
1454 }
1455 };
1456
1457 inline flatbuffers::Offset<BertTokenizerOptions> CreateBertTokenizerOptions(
1458 flatbuffers::FlatBufferBuilder &_fbb,
1459 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> vocab_file = 0) {
1460 BertTokenizerOptionsBuilder builder_(_fbb);
1461 builder_.add_vocab_file(vocab_file);
1462 return builder_.Finish();
1463 }
1464
1465 inline flatbuffers::Offset<BertTokenizerOptions> CreateBertTokenizerOptionsDirect(
1466 flatbuffers::FlatBufferBuilder &_fbb,
1467 const std::vector<flatbuffers::Offset<tflite::AssociatedFile>> *vocab_file = nullptr) {
1468 auto vocab_file__ = vocab_file ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>>(*vocab_file) : 0;
1469 return tflite::CreateBertTokenizerOptions(
1470 _fbb,
1471 vocab_file__);
1472 }
1473
1474 flatbuffers::Offset<BertTokenizerOptions> CreateBertTokenizerOptions(flatbuffers::FlatBufferBuilder &_fbb, const BertTokenizerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1475
1476 struct SentencePieceTokenizerOptionsT : public flatbuffers::NativeTable {
1477 typedef SentencePieceTokenizerOptions TableType;
1478 std::vector<std::unique_ptr<tflite::AssociatedFileT>> sentencePiece_model{};
1479 std::vector<std::unique_ptr<tflite::AssociatedFileT>> vocab_file{};
1480 SentencePieceTokenizerOptionsT() = default;
1481 SentencePieceTokenizerOptionsT(const SentencePieceTokenizerOptionsT &o);
1482 SentencePieceTokenizerOptionsT(SentencePieceTokenizerOptionsT&&) FLATBUFFERS_NOEXCEPT = default;
1483 SentencePieceTokenizerOptionsT &operator=(SentencePieceTokenizerOptionsT o) FLATBUFFERS_NOEXCEPT;
1484 };
1485
1486 struct SentencePieceTokenizerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1487 typedef SentencePieceTokenizerOptionsT NativeTableType;
1488 typedef SentencePieceTokenizerOptionsBuilder Builder;
1489 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1490 VT_SENTENCEPIECE_MODEL = 4,
1491 VT_VOCAB_FILE = 6
1492 };
1493 const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *sentencePiece_model() const {
1494 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *>(VT_SENTENCEPIECE_MODEL);
1495 }
1496 const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *vocab_file() const {
1497 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *>(VT_VOCAB_FILE);
1498 }
1499 bool Verify(flatbuffers::Verifier &verifier) const {
1500 return VerifyTableStart(verifier) &&
1501 VerifyOffset(verifier, VT_SENTENCEPIECE_MODEL) &&
1502 verifier.VerifyVector(sentencePiece_model()) &&
1503 verifier.VerifyVectorOfTables(sentencePiece_model()) &&
1504 VerifyOffset(verifier, VT_VOCAB_FILE) &&
1505 verifier.VerifyVector(vocab_file()) &&
1506 verifier.VerifyVectorOfTables(vocab_file()) &&
1507 verifier.EndTable();
1508 }
1509 SentencePieceTokenizerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1510 void UnPackTo(SentencePieceTokenizerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1511 static flatbuffers::Offset<SentencePieceTokenizerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SentencePieceTokenizerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1512 };
1513
1514 struct SentencePieceTokenizerOptionsBuilder {
1515 typedef SentencePieceTokenizerOptions Table;
1516 flatbuffers::FlatBufferBuilder &fbb_;
1517 flatbuffers::uoffset_t start_;
1518 void add_sentencePiece_model(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> sentencePiece_model) {
1519 fbb_.AddOffset(SentencePieceTokenizerOptions::VT_SENTENCEPIECE_MODEL, sentencePiece_model);
1520 }
1521 void add_vocab_file(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> vocab_file) {
1522 fbb_.AddOffset(SentencePieceTokenizerOptions::VT_VOCAB_FILE, vocab_file);
1523 }
1524 explicit SentencePieceTokenizerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1525 : fbb_(_fbb) {
1526 start_ = fbb_.StartTable();
1527 }
1528 flatbuffers::Offset<SentencePieceTokenizerOptions> Finish() {
1529 const auto end = fbb_.EndTable(start_);
1530 auto o = flatbuffers::Offset<SentencePieceTokenizerOptions>(end);
1531 return o;
1532 }
1533 };
1534
1535 inline flatbuffers::Offset<SentencePieceTokenizerOptions> CreateSentencePieceTokenizerOptions(
1536 flatbuffers::FlatBufferBuilder &_fbb,
1537 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> sentencePiece_model = 0,
1538 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> vocab_file = 0) {
1539 SentencePieceTokenizerOptionsBuilder builder_(_fbb);
1540 builder_.add_vocab_file(vocab_file);
1541 builder_.add_sentencePiece_model(sentencePiece_model);
1542 return builder_.Finish();
1543 }
1544
1545 inline flatbuffers::Offset<SentencePieceTokenizerOptions> CreateSentencePieceTokenizerOptionsDirect(
1546 flatbuffers::FlatBufferBuilder &_fbb,
1547 const std::vector<flatbuffers::Offset<tflite::AssociatedFile>> *sentencePiece_model = nullptr,
1548 const std::vector<flatbuffers::Offset<tflite::AssociatedFile>> *vocab_file = nullptr) {
1549 auto sentencePiece_model__ = sentencePiece_model ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>>(*sentencePiece_model) : 0;
1550 auto vocab_file__ = vocab_file ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>>(*vocab_file) : 0;
1551 return tflite::CreateSentencePieceTokenizerOptions(
1552 _fbb,
1553 sentencePiece_model__,
1554 vocab_file__);
1555 }
1556
1557 flatbuffers::Offset<SentencePieceTokenizerOptions> CreateSentencePieceTokenizerOptions(flatbuffers::FlatBufferBuilder &_fbb, const SentencePieceTokenizerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1558
1559 struct RegexTokenizerOptionsT : public flatbuffers::NativeTable {
1560 typedef RegexTokenizerOptions TableType;
1561 std::string delim_regex_pattern{};
1562 std::vector<std::unique_ptr<tflite::AssociatedFileT>> vocab_file{};
1563 RegexTokenizerOptionsT() = default;
1564 RegexTokenizerOptionsT(const RegexTokenizerOptionsT &o);
1565 RegexTokenizerOptionsT(RegexTokenizerOptionsT&&) FLATBUFFERS_NOEXCEPT = default;
1566 RegexTokenizerOptionsT &operator=(RegexTokenizerOptionsT o) FLATBUFFERS_NOEXCEPT;
1567 };
1568
1569 struct RegexTokenizerOptions FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1570 typedef RegexTokenizerOptionsT NativeTableType;
1571 typedef RegexTokenizerOptionsBuilder Builder;
1572 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1573 VT_DELIM_REGEX_PATTERN = 4,
1574 VT_VOCAB_FILE = 6
1575 };
1576 const flatbuffers::String *delim_regex_pattern() const {
1577 return GetPointer<const flatbuffers::String *>(VT_DELIM_REGEX_PATTERN);
1578 }
1579 const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *vocab_file() const {
1580 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *>(VT_VOCAB_FILE);
1581 }
1582 bool Verify(flatbuffers::Verifier &verifier) const {
1583 return VerifyTableStart(verifier) &&
1584 VerifyOffset(verifier, VT_DELIM_REGEX_PATTERN) &&
1585 verifier.VerifyString(delim_regex_pattern()) &&
1586 VerifyOffset(verifier, VT_VOCAB_FILE) &&
1587 verifier.VerifyVector(vocab_file()) &&
1588 verifier.VerifyVectorOfTables(vocab_file()) &&
1589 verifier.EndTable();
1590 }
1591 RegexTokenizerOptionsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1592 void UnPackTo(RegexTokenizerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1593 static flatbuffers::Offset<RegexTokenizerOptions> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegexTokenizerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1594 };
1595
1596 struct RegexTokenizerOptionsBuilder {
1597 typedef RegexTokenizerOptions Table;
1598 flatbuffers::FlatBufferBuilder &fbb_;
1599 flatbuffers::uoffset_t start_;
1600 void add_delim_regex_pattern(flatbuffers::Offset<flatbuffers::String> delim_regex_pattern) {
1601 fbb_.AddOffset(RegexTokenizerOptions::VT_DELIM_REGEX_PATTERN, delim_regex_pattern);
1602 }
1603 void add_vocab_file(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> vocab_file) {
1604 fbb_.AddOffset(RegexTokenizerOptions::VT_VOCAB_FILE, vocab_file);
1605 }
1606 explicit RegexTokenizerOptionsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1607 : fbb_(_fbb) {
1608 start_ = fbb_.StartTable();
1609 }
1610 flatbuffers::Offset<RegexTokenizerOptions> Finish() {
1611 const auto end = fbb_.EndTable(start_);
1612 auto o = flatbuffers::Offset<RegexTokenizerOptions>(end);
1613 return o;
1614 }
1615 };
1616
1617 inline flatbuffers::Offset<RegexTokenizerOptions> CreateRegexTokenizerOptions(
1618 flatbuffers::FlatBufferBuilder &_fbb,
1619 flatbuffers::Offset<flatbuffers::String> delim_regex_pattern = 0,
1620 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> vocab_file = 0) {
1621 RegexTokenizerOptionsBuilder builder_(_fbb);
1622 builder_.add_vocab_file(vocab_file);
1623 builder_.add_delim_regex_pattern(delim_regex_pattern);
1624 return builder_.Finish();
1625 }
1626
1627 inline flatbuffers::Offset<RegexTokenizerOptions> CreateRegexTokenizerOptionsDirect(
1628 flatbuffers::FlatBufferBuilder &_fbb,
1629 const char *delim_regex_pattern = nullptr,
1630 const std::vector<flatbuffers::Offset<tflite::AssociatedFile>> *vocab_file = nullptr) {
1631 auto delim_regex_pattern__ = delim_regex_pattern ? _fbb.CreateString(delim_regex_pattern) : 0;
1632 auto vocab_file__ = vocab_file ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>>(*vocab_file) : 0;
1633 return tflite::CreateRegexTokenizerOptions(
1634 _fbb,
1635 delim_regex_pattern__,
1636 vocab_file__);
1637 }
1638
1639 flatbuffers::Offset<RegexTokenizerOptions> CreateRegexTokenizerOptions(flatbuffers::FlatBufferBuilder &_fbb, const RegexTokenizerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1640
1641 struct ProcessUnitT : public flatbuffers::NativeTable {
1642 typedef ProcessUnit TableType;
1643 tflite::ProcessUnitOptionsUnion options{};
1644 };
1645
1646 struct ProcessUnit FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1647 typedef ProcessUnitT NativeTableType;
1648 typedef ProcessUnitBuilder Builder;
1649 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1650 VT_OPTIONS_TYPE = 4,
1651 VT_OPTIONS = 6
1652 };
1653 tflite::ProcessUnitOptions options_type() const {
1654 return static_cast<tflite::ProcessUnitOptions>(GetField<uint8_t>(VT_OPTIONS_TYPE, 0));
1655 }
1656 const void *options() const {
1657 return GetPointer<const void *>(VT_OPTIONS);
1658 }
1659 template<typename T> const T *options_as() const;
1660 const tflite::NormalizationOptions *options_as_NormalizationOptions() const {
1661 return options_type() == tflite::ProcessUnitOptions_NormalizationOptions ? static_cast<const tflite::NormalizationOptions *>(options()) : nullptr;
1662 }
1663 const tflite::ScoreCalibrationOptions *options_as_ScoreCalibrationOptions() const {
1664 return options_type() == tflite::ProcessUnitOptions_ScoreCalibrationOptions ? static_cast<const tflite::ScoreCalibrationOptions *>(options()) : nullptr;
1665 }
1666 const tflite::ScoreThresholdingOptions *options_as_ScoreThresholdingOptions() const {
1667 return options_type() == tflite::ProcessUnitOptions_ScoreThresholdingOptions ? static_cast<const tflite::ScoreThresholdingOptions *>(options()) : nullptr;
1668 }
1669 const tflite::BertTokenizerOptions *options_as_BertTokenizerOptions() const {
1670 return options_type() == tflite::ProcessUnitOptions_BertTokenizerOptions ? static_cast<const tflite::BertTokenizerOptions *>(options()) : nullptr;
1671 }
1672 const tflite::SentencePieceTokenizerOptions *options_as_SentencePieceTokenizerOptions() const {
1673 return options_type() == tflite::ProcessUnitOptions_SentencePieceTokenizerOptions ? static_cast<const tflite::SentencePieceTokenizerOptions *>(options()) : nullptr;
1674 }
1675 const tflite::RegexTokenizerOptions *options_as_RegexTokenizerOptions() const {
1676 return options_type() == tflite::ProcessUnitOptions_RegexTokenizerOptions ? static_cast<const tflite::RegexTokenizerOptions *>(options()) : nullptr;
1677 }
1678 bool Verify(flatbuffers::Verifier &verifier) const {
1679 return VerifyTableStart(verifier) &&
1680 VerifyField<uint8_t>(verifier, VT_OPTIONS_TYPE, 1) &&
1681 VerifyOffset(verifier, VT_OPTIONS) &&
1682 VerifyProcessUnitOptions(verifier, options(), options_type()) &&
1683 verifier.EndTable();
1684 }
1685 ProcessUnitT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1686 void UnPackTo(ProcessUnitT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1687 static flatbuffers::Offset<ProcessUnit> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ProcessUnitT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1688 };
1689
1690 template<> inline const tflite::NormalizationOptions *ProcessUnit::options_as<tflite::NormalizationOptions>() const {
1691 return options_as_NormalizationOptions();
1692 }
1693
1694 template<> inline const tflite::ScoreCalibrationOptions *ProcessUnit::options_as<tflite::ScoreCalibrationOptions>() const {
1695 return options_as_ScoreCalibrationOptions();
1696 }
1697
1698 template<> inline const tflite::ScoreThresholdingOptions *ProcessUnit::options_as<tflite::ScoreThresholdingOptions>() const {
1699 return options_as_ScoreThresholdingOptions();
1700 }
1701
1702 template<> inline const tflite::BertTokenizerOptions *ProcessUnit::options_as<tflite::BertTokenizerOptions>() const {
1703 return options_as_BertTokenizerOptions();
1704 }
1705
1706 template<> inline const tflite::SentencePieceTokenizerOptions *ProcessUnit::options_as<tflite::SentencePieceTokenizerOptions>() const {
1707 return options_as_SentencePieceTokenizerOptions();
1708 }
1709
1710 template<> inline const tflite::RegexTokenizerOptions *ProcessUnit::options_as<tflite::RegexTokenizerOptions>() const {
1711 return options_as_RegexTokenizerOptions();
1712 }
1713
1714 struct ProcessUnitBuilder {
1715 typedef ProcessUnit Table;
1716 flatbuffers::FlatBufferBuilder &fbb_;
1717 flatbuffers::uoffset_t start_;
1718 void add_options_type(tflite::ProcessUnitOptions options_type) {
1719 fbb_.AddElement<uint8_t>(ProcessUnit::VT_OPTIONS_TYPE, static_cast<uint8_t>(options_type), 0);
1720 }
1721 void add_options(flatbuffers::Offset<void> options) {
1722 fbb_.AddOffset(ProcessUnit::VT_OPTIONS, options);
1723 }
1724 explicit ProcessUnitBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1725 : fbb_(_fbb) {
1726 start_ = fbb_.StartTable();
1727 }
1728 flatbuffers::Offset<ProcessUnit> Finish() {
1729 const auto end = fbb_.EndTable(start_);
1730 auto o = flatbuffers::Offset<ProcessUnit>(end);
1731 return o;
1732 }
1733 };
1734
1735 inline flatbuffers::Offset<ProcessUnit> CreateProcessUnit(
1736 flatbuffers::FlatBufferBuilder &_fbb,
1737 tflite::ProcessUnitOptions options_type = tflite::ProcessUnitOptions_NONE,
1738 flatbuffers::Offset<void> options = 0) {
1739 ProcessUnitBuilder builder_(_fbb);
1740 builder_.add_options(options);
1741 builder_.add_options_type(options_type);
1742 return builder_.Finish();
1743 }
1744
1745 flatbuffers::Offset<ProcessUnit> CreateProcessUnit(flatbuffers::FlatBufferBuilder &_fbb, const ProcessUnitT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1746
1747 struct StatsT : public flatbuffers::NativeTable {
1748 typedef Stats TableType;
1749 std::vector<float> max{};
1750 std::vector<float> min{};
1751 };
1752
1753 struct Stats FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1754 typedef StatsT NativeTableType;
1755 typedef StatsBuilder Builder;
1756 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1757 VT_MAX = 4,
1758 VT_MIN = 6
1759 };
1760 const flatbuffers::Vector<float> *max() const {
1761 return GetPointer<const flatbuffers::Vector<float> *>(VT_MAX);
1762 }
1763 const flatbuffers::Vector<float> *min() const {
1764 return GetPointer<const flatbuffers::Vector<float> *>(VT_MIN);
1765 }
1766 bool Verify(flatbuffers::Verifier &verifier) const {
1767 return VerifyTableStart(verifier) &&
1768 VerifyOffset(verifier, VT_MAX) &&
1769 verifier.VerifyVector(max()) &&
1770 VerifyOffset(verifier, VT_MIN) &&
1771 verifier.VerifyVector(min()) &&
1772 verifier.EndTable();
1773 }
1774 StatsT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1775 void UnPackTo(StatsT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1776 static flatbuffers::Offset<Stats> Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatsT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1777 };
1778
1779 struct StatsBuilder {
1780 typedef Stats Table;
1781 flatbuffers::FlatBufferBuilder &fbb_;
1782 flatbuffers::uoffset_t start_;
1783 void add_max(flatbuffers::Offset<flatbuffers::Vector<float>> max) {
1784 fbb_.AddOffset(Stats::VT_MAX, max);
1785 }
1786 void add_min(flatbuffers::Offset<flatbuffers::Vector<float>> min) {
1787 fbb_.AddOffset(Stats::VT_MIN, min);
1788 }
1789 explicit StatsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1790 : fbb_(_fbb) {
1791 start_ = fbb_.StartTable();
1792 }
1793 flatbuffers::Offset<Stats> Finish() {
1794 const auto end = fbb_.EndTable(start_);
1795 auto o = flatbuffers::Offset<Stats>(end);
1796 return o;
1797 }
1798 };
1799
1800 inline flatbuffers::Offset<Stats> CreateStats(
1801 flatbuffers::FlatBufferBuilder &_fbb,
1802 flatbuffers::Offset<flatbuffers::Vector<float>> max = 0,
1803 flatbuffers::Offset<flatbuffers::Vector<float>> min = 0) {
1804 StatsBuilder builder_(_fbb);
1805 builder_.add_min(min);
1806 builder_.add_max(max);
1807 return builder_.Finish();
1808 }
1809
1810 inline flatbuffers::Offset<Stats> CreateStatsDirect(
1811 flatbuffers::FlatBufferBuilder &_fbb,
1812 const std::vector<float> *max = nullptr,
1813 const std::vector<float> *min = nullptr) {
1814 auto max__ = max ? _fbb.CreateVector<float>(*max) : 0;
1815 auto min__ = min ? _fbb.CreateVector<float>(*min) : 0;
1816 return tflite::CreateStats(
1817 _fbb,
1818 max__,
1819 min__);
1820 }
1821
1822 flatbuffers::Offset<Stats> CreateStats(flatbuffers::FlatBufferBuilder &_fbb, const StatsT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1823
1824 struct TensorGroupT : public flatbuffers::NativeTable {
1825 typedef TensorGroup TableType;
1826 std::string name{};
1827 std::vector<std::string> tensor_names{};
1828 };
1829
1830 struct TensorGroup FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1831 typedef TensorGroupT NativeTableType;
1832 typedef TensorGroupBuilder Builder;
1833 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1834 VT_NAME = 4,
1835 VT_TENSOR_NAMES = 6
1836 };
1837 const flatbuffers::String *name() const {
1838 return GetPointer<const flatbuffers::String *>(VT_NAME);
1839 }
1840 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *tensor_names() const {
1841 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_TENSOR_NAMES);
1842 }
1843 bool Verify(flatbuffers::Verifier &verifier) const {
1844 return VerifyTableStart(verifier) &&
1845 VerifyOffset(verifier, VT_NAME) &&
1846 verifier.VerifyString(name()) &&
1847 VerifyOffset(verifier, VT_TENSOR_NAMES) &&
1848 verifier.VerifyVector(tensor_names()) &&
1849 verifier.VerifyVectorOfStrings(tensor_names()) &&
1850 verifier.EndTable();
1851 }
1852 TensorGroupT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1853 void UnPackTo(TensorGroupT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1854 static flatbuffers::Offset<TensorGroup> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorGroupT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1855 };
1856
1857 struct TensorGroupBuilder {
1858 typedef TensorGroup Table;
1859 flatbuffers::FlatBufferBuilder &fbb_;
1860 flatbuffers::uoffset_t start_;
1861 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
1862 fbb_.AddOffset(TensorGroup::VT_NAME, name);
1863 }
1864 void add_tensor_names(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> tensor_names) {
1865 fbb_.AddOffset(TensorGroup::VT_TENSOR_NAMES, tensor_names);
1866 }
1867 explicit TensorGroupBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1868 : fbb_(_fbb) {
1869 start_ = fbb_.StartTable();
1870 }
1871 flatbuffers::Offset<TensorGroup> Finish() {
1872 const auto end = fbb_.EndTable(start_);
1873 auto o = flatbuffers::Offset<TensorGroup>(end);
1874 return o;
1875 }
1876 };
1877
1878 inline flatbuffers::Offset<TensorGroup> CreateTensorGroup(
1879 flatbuffers::FlatBufferBuilder &_fbb,
1880 flatbuffers::Offset<flatbuffers::String> name = 0,
1881 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> tensor_names = 0) {
1882 TensorGroupBuilder builder_(_fbb);
1883 builder_.add_tensor_names(tensor_names);
1884 builder_.add_name(name);
1885 return builder_.Finish();
1886 }
1887
1888 inline flatbuffers::Offset<TensorGroup> CreateTensorGroupDirect(
1889 flatbuffers::FlatBufferBuilder &_fbb,
1890 const char *name = nullptr,
1891 const std::vector<flatbuffers::Offset<flatbuffers::String>> *tensor_names = nullptr) {
1892 auto name__ = name ? _fbb.CreateString(name) : 0;
1893 auto tensor_names__ = tensor_names ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*tensor_names) : 0;
1894 return tflite::CreateTensorGroup(
1895 _fbb,
1896 name__,
1897 tensor_names__);
1898 }
1899
1900 flatbuffers::Offset<TensorGroup> CreateTensorGroup(flatbuffers::FlatBufferBuilder &_fbb, const TensorGroupT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1901
1902 struct TensorMetadataT : public flatbuffers::NativeTable {
1903 typedef TensorMetadata TableType;
1904 std::string name{};
1905 std::string description{};
1906 std::vector<std::string> dimension_names{};
1907 std::unique_ptr<tflite::ContentT> content{};
1908 std::vector<std::unique_ptr<tflite::ProcessUnitT>> process_units{};
1909 std::unique_ptr<tflite::StatsT> stats{};
1910 std::vector<std::unique_ptr<tflite::AssociatedFileT>> associated_files{};
1911 TensorMetadataT() = default;
1912 TensorMetadataT(const TensorMetadataT &o);
1913 TensorMetadataT(TensorMetadataT&&) FLATBUFFERS_NOEXCEPT = default;
1914 TensorMetadataT &operator=(TensorMetadataT o) FLATBUFFERS_NOEXCEPT;
1915 };
1916
1917 struct TensorMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1918 typedef TensorMetadataT NativeTableType;
1919 typedef TensorMetadataBuilder Builder;
1920 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1921 VT_NAME = 4,
1922 VT_DESCRIPTION = 6,
1923 VT_DIMENSION_NAMES = 8,
1924 VT_CONTENT = 10,
1925 VT_PROCESS_UNITS = 12,
1926 VT_STATS = 14,
1927 VT_ASSOCIATED_FILES = 16
1928 };
1929 const flatbuffers::String *name() const {
1930 return GetPointer<const flatbuffers::String *>(VT_NAME);
1931 }
1932 const flatbuffers::String *description() const {
1933 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
1934 }
1935 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *dimension_names() const {
1936 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DIMENSION_NAMES);
1937 }
1938 const tflite::Content *content() const {
1939 return GetPointer<const tflite::Content *>(VT_CONTENT);
1940 }
1941 const flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>> *process_units() const {
1942 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>> *>(VT_PROCESS_UNITS);
1943 }
1944 const tflite::Stats *stats() const {
1945 return GetPointer<const tflite::Stats *>(VT_STATS);
1946 }
1947 const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *associated_files() const {
1948 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *>(VT_ASSOCIATED_FILES);
1949 }
1950 bool Verify(flatbuffers::Verifier &verifier) const {
1951 return VerifyTableStart(verifier) &&
1952 VerifyOffset(verifier, VT_NAME) &&
1953 verifier.VerifyString(name()) &&
1954 VerifyOffset(verifier, VT_DESCRIPTION) &&
1955 verifier.VerifyString(description()) &&
1956 VerifyOffset(verifier, VT_DIMENSION_NAMES) &&
1957 verifier.VerifyVector(dimension_names()) &&
1958 verifier.VerifyVectorOfStrings(dimension_names()) &&
1959 VerifyOffset(verifier, VT_CONTENT) &&
1960 verifier.VerifyTable(content()) &&
1961 VerifyOffset(verifier, VT_PROCESS_UNITS) &&
1962 verifier.VerifyVector(process_units()) &&
1963 verifier.VerifyVectorOfTables(process_units()) &&
1964 VerifyOffset(verifier, VT_STATS) &&
1965 verifier.VerifyTable(stats()) &&
1966 VerifyOffset(verifier, VT_ASSOCIATED_FILES) &&
1967 verifier.VerifyVector(associated_files()) &&
1968 verifier.VerifyVectorOfTables(associated_files()) &&
1969 verifier.EndTable();
1970 }
1971 TensorMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1972 void UnPackTo(TensorMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1973 static flatbuffers::Offset<TensorMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1974 };
1975
1976 struct TensorMetadataBuilder {
1977 typedef TensorMetadata Table;
1978 flatbuffers::FlatBufferBuilder &fbb_;
1979 flatbuffers::uoffset_t start_;
1980 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
1981 fbb_.AddOffset(TensorMetadata::VT_NAME, name);
1982 }
1983 void add_description(flatbuffers::Offset<flatbuffers::String> description) {
1984 fbb_.AddOffset(TensorMetadata::VT_DESCRIPTION, description);
1985 }
1986 void add_dimension_names(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> dimension_names) {
1987 fbb_.AddOffset(TensorMetadata::VT_DIMENSION_NAMES, dimension_names);
1988 }
1989 void add_content(flatbuffers::Offset<tflite::Content> content) {
1990 fbb_.AddOffset(TensorMetadata::VT_CONTENT, content);
1991 }
1992 void add_process_units(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>>> process_units) {
1993 fbb_.AddOffset(TensorMetadata::VT_PROCESS_UNITS, process_units);
1994 }
1995 void add_stats(flatbuffers::Offset<tflite::Stats> stats) {
1996 fbb_.AddOffset(TensorMetadata::VT_STATS, stats);
1997 }
1998 void add_associated_files(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> associated_files) {
1999 fbb_.AddOffset(TensorMetadata::VT_ASSOCIATED_FILES, associated_files);
2000 }
2001 explicit TensorMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2002 : fbb_(_fbb) {
2003 start_ = fbb_.StartTable();
2004 }
2005 flatbuffers::Offset<TensorMetadata> Finish() {
2006 const auto end = fbb_.EndTable(start_);
2007 auto o = flatbuffers::Offset<TensorMetadata>(end);
2008 return o;
2009 }
2010 };
2011
2012 inline flatbuffers::Offset<TensorMetadata> CreateTensorMetadata(
2013 flatbuffers::FlatBufferBuilder &_fbb,
2014 flatbuffers::Offset<flatbuffers::String> name = 0,
2015 flatbuffers::Offset<flatbuffers::String> description = 0,
2016 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> dimension_names = 0,
2017 flatbuffers::Offset<tflite::Content> content = 0,
2018 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>>> process_units = 0,
2019 flatbuffers::Offset<tflite::Stats> stats = 0,
2020 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> associated_files = 0) {
2021 TensorMetadataBuilder builder_(_fbb);
2022 builder_.add_associated_files(associated_files);
2023 builder_.add_stats(stats);
2024 builder_.add_process_units(process_units);
2025 builder_.add_content(content);
2026 builder_.add_dimension_names(dimension_names);
2027 builder_.add_description(description);
2028 builder_.add_name(name);
2029 return builder_.Finish();
2030 }
2031
2032 inline flatbuffers::Offset<TensorMetadata> CreateTensorMetadataDirect(
2033 flatbuffers::FlatBufferBuilder &_fbb,
2034 const char *name = nullptr,
2035 const char *description = nullptr,
2036 const std::vector<flatbuffers::Offset<flatbuffers::String>> *dimension_names = nullptr,
2037 flatbuffers::Offset<tflite::Content> content = 0,
2038 const std::vector<flatbuffers::Offset<tflite::ProcessUnit>> *process_units = nullptr,
2039 flatbuffers::Offset<tflite::Stats> stats = 0,
2040 const std::vector<flatbuffers::Offset<tflite::AssociatedFile>> *associated_files = nullptr) {
2041 auto name__ = name ? _fbb.CreateString(name) : 0;
2042 auto description__ = description ? _fbb.CreateString(description) : 0;
2043 auto dimension_names__ = dimension_names ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*dimension_names) : 0;
2044 auto process_units__ = process_units ? _fbb.CreateVector<flatbuffers::Offset<tflite::ProcessUnit>>(*process_units) : 0;
2045 auto associated_files__ = associated_files ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>>(*associated_files) : 0;
2046 return tflite::CreateTensorMetadata(
2047 _fbb,
2048 name__,
2049 description__,
2050 dimension_names__,
2051 content,
2052 process_units__,
2053 stats,
2054 associated_files__);
2055 }
2056
2057 flatbuffers::Offset<TensorMetadata> CreateTensorMetadata(flatbuffers::FlatBufferBuilder &_fbb, const TensorMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2058
2059 struct SubGraphMetadataT : public flatbuffers::NativeTable {
2060 typedef SubGraphMetadata TableType;
2061 std::string name{};
2062 std::string description{};
2063 std::vector<std::unique_ptr<tflite::TensorMetadataT>> input_tensor_metadata{};
2064 std::vector<std::unique_ptr<tflite::TensorMetadataT>> output_tensor_metadata{};
2065 std::vector<std::unique_ptr<tflite::AssociatedFileT>> associated_files{};
2066 std::vector<std::unique_ptr<tflite::ProcessUnitT>> input_process_units{};
2067 std::vector<std::unique_ptr<tflite::ProcessUnitT>> output_process_units{};
2068 std::vector<std::unique_ptr<tflite::TensorGroupT>> input_tensor_groups{};
2069 std::vector<std::unique_ptr<tflite::TensorGroupT>> output_tensor_groups{};
2070 SubGraphMetadataT() = default;
2071 SubGraphMetadataT(const SubGraphMetadataT &o);
2072 SubGraphMetadataT(SubGraphMetadataT&&) FLATBUFFERS_NOEXCEPT = default;
2073 SubGraphMetadataT &operator=(SubGraphMetadataT o) FLATBUFFERS_NOEXCEPT;
2074 };
2075
2076 struct SubGraphMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2077 typedef SubGraphMetadataT NativeTableType;
2078 typedef SubGraphMetadataBuilder Builder;
2079 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2080 VT_NAME = 4,
2081 VT_DESCRIPTION = 6,
2082 VT_INPUT_TENSOR_METADATA = 8,
2083 VT_OUTPUT_TENSOR_METADATA = 10,
2084 VT_ASSOCIATED_FILES = 12,
2085 VT_INPUT_PROCESS_UNITS = 14,
2086 VT_OUTPUT_PROCESS_UNITS = 16,
2087 VT_INPUT_TENSOR_GROUPS = 18,
2088 VT_OUTPUT_TENSOR_GROUPS = 20
2089 };
2090 const flatbuffers::String *name() const {
2091 return GetPointer<const flatbuffers::String *>(VT_NAME);
2092 }
2093 const flatbuffers::String *description() const {
2094 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
2095 }
2096 const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>> *input_tensor_metadata() const {
2097 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>> *>(VT_INPUT_TENSOR_METADATA);
2098 }
2099 const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>> *output_tensor_metadata() const {
2100 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>> *>(VT_OUTPUT_TENSOR_METADATA);
2101 }
2102 const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *associated_files() const {
2103 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *>(VT_ASSOCIATED_FILES);
2104 }
2105 const flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>> *input_process_units() const {
2106 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>> *>(VT_INPUT_PROCESS_UNITS);
2107 }
2108 const flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>> *output_process_units() const {
2109 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>> *>(VT_OUTPUT_PROCESS_UNITS);
2110 }
2111 const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>> *input_tensor_groups() const {
2112 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>> *>(VT_INPUT_TENSOR_GROUPS);
2113 }
2114 const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>> *output_tensor_groups() const {
2115 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>> *>(VT_OUTPUT_TENSOR_GROUPS);
2116 }
2117 bool Verify(flatbuffers::Verifier &verifier) const {
2118 return VerifyTableStart(verifier) &&
2119 VerifyOffset(verifier, VT_NAME) &&
2120 verifier.VerifyString(name()) &&
2121 VerifyOffset(verifier, VT_DESCRIPTION) &&
2122 verifier.VerifyString(description()) &&
2123 VerifyOffset(verifier, VT_INPUT_TENSOR_METADATA) &&
2124 verifier.VerifyVector(input_tensor_metadata()) &&
2125 verifier.VerifyVectorOfTables(input_tensor_metadata()) &&
2126 VerifyOffset(verifier, VT_OUTPUT_TENSOR_METADATA) &&
2127 verifier.VerifyVector(output_tensor_metadata()) &&
2128 verifier.VerifyVectorOfTables(output_tensor_metadata()) &&
2129 VerifyOffset(verifier, VT_ASSOCIATED_FILES) &&
2130 verifier.VerifyVector(associated_files()) &&
2131 verifier.VerifyVectorOfTables(associated_files()) &&
2132 VerifyOffset(verifier, VT_INPUT_PROCESS_UNITS) &&
2133 verifier.VerifyVector(input_process_units()) &&
2134 verifier.VerifyVectorOfTables(input_process_units()) &&
2135 VerifyOffset(verifier, VT_OUTPUT_PROCESS_UNITS) &&
2136 verifier.VerifyVector(output_process_units()) &&
2137 verifier.VerifyVectorOfTables(output_process_units()) &&
2138 VerifyOffset(verifier, VT_INPUT_TENSOR_GROUPS) &&
2139 verifier.VerifyVector(input_tensor_groups()) &&
2140 verifier.VerifyVectorOfTables(input_tensor_groups()) &&
2141 VerifyOffset(verifier, VT_OUTPUT_TENSOR_GROUPS) &&
2142 verifier.VerifyVector(output_tensor_groups()) &&
2143 verifier.VerifyVectorOfTables(output_tensor_groups()) &&
2144 verifier.EndTable();
2145 }
2146 SubGraphMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2147 void UnPackTo(SubGraphMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2148 static flatbuffers::Offset<SubGraphMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2149 };
2150
2151 struct SubGraphMetadataBuilder {
2152 typedef SubGraphMetadata Table;
2153 flatbuffers::FlatBufferBuilder &fbb_;
2154 flatbuffers::uoffset_t start_;
2155 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
2156 fbb_.AddOffset(SubGraphMetadata::VT_NAME, name);
2157 }
2158 void add_description(flatbuffers::Offset<flatbuffers::String> description) {
2159 fbb_.AddOffset(SubGraphMetadata::VT_DESCRIPTION, description);
2160 }
2161 void add_input_tensor_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>>> input_tensor_metadata) {
2162 fbb_.AddOffset(SubGraphMetadata::VT_INPUT_TENSOR_METADATA, input_tensor_metadata);
2163 }
2164 void add_output_tensor_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>>> output_tensor_metadata) {
2165 fbb_.AddOffset(SubGraphMetadata::VT_OUTPUT_TENSOR_METADATA, output_tensor_metadata);
2166 }
2167 void add_associated_files(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> associated_files) {
2168 fbb_.AddOffset(SubGraphMetadata::VT_ASSOCIATED_FILES, associated_files);
2169 }
2170 void add_input_process_units(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>>> input_process_units) {
2171 fbb_.AddOffset(SubGraphMetadata::VT_INPUT_PROCESS_UNITS, input_process_units);
2172 }
2173 void add_output_process_units(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>>> output_process_units) {
2174 fbb_.AddOffset(SubGraphMetadata::VT_OUTPUT_PROCESS_UNITS, output_process_units);
2175 }
2176 void add_input_tensor_groups(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>>> input_tensor_groups) {
2177 fbb_.AddOffset(SubGraphMetadata::VT_INPUT_TENSOR_GROUPS, input_tensor_groups);
2178 }
2179 void add_output_tensor_groups(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>>> output_tensor_groups) {
2180 fbb_.AddOffset(SubGraphMetadata::VT_OUTPUT_TENSOR_GROUPS, output_tensor_groups);
2181 }
2182 explicit SubGraphMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2183 : fbb_(_fbb) {
2184 start_ = fbb_.StartTable();
2185 }
2186 flatbuffers::Offset<SubGraphMetadata> Finish() {
2187 const auto end = fbb_.EndTable(start_);
2188 auto o = flatbuffers::Offset<SubGraphMetadata>(end);
2189 return o;
2190 }
2191 };
2192
2193 inline flatbuffers::Offset<SubGraphMetadata> CreateSubGraphMetadata(
2194 flatbuffers::FlatBufferBuilder &_fbb,
2195 flatbuffers::Offset<flatbuffers::String> name = 0,
2196 flatbuffers::Offset<flatbuffers::String> description = 0,
2197 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>>> input_tensor_metadata = 0,
2198 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorMetadata>>> output_tensor_metadata = 0,
2199 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> associated_files = 0,
2200 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>>> input_process_units = 0,
2201 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::ProcessUnit>>> output_process_units = 0,
2202 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>>> input_tensor_groups = 0,
2203 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::TensorGroup>>> output_tensor_groups = 0) {
2204 SubGraphMetadataBuilder builder_(_fbb);
2205 builder_.add_output_tensor_groups(output_tensor_groups);
2206 builder_.add_input_tensor_groups(input_tensor_groups);
2207 builder_.add_output_process_units(output_process_units);
2208 builder_.add_input_process_units(input_process_units);
2209 builder_.add_associated_files(associated_files);
2210 builder_.add_output_tensor_metadata(output_tensor_metadata);
2211 builder_.add_input_tensor_metadata(input_tensor_metadata);
2212 builder_.add_description(description);
2213 builder_.add_name(name);
2214 return builder_.Finish();
2215 }
2216
2217 inline flatbuffers::Offset<SubGraphMetadata> CreateSubGraphMetadataDirect(
2218 flatbuffers::FlatBufferBuilder &_fbb,
2219 const char *name = nullptr,
2220 const char *description = nullptr,
2221 const std::vector<flatbuffers::Offset<tflite::TensorMetadata>> *input_tensor_metadata = nullptr,
2222 const std::vector<flatbuffers::Offset<tflite::TensorMetadata>> *output_tensor_metadata = nullptr,
2223 const std::vector<flatbuffers::Offset<tflite::AssociatedFile>> *associated_files = nullptr,
2224 const std::vector<flatbuffers::Offset<tflite::ProcessUnit>> *input_process_units = nullptr,
2225 const std::vector<flatbuffers::Offset<tflite::ProcessUnit>> *output_process_units = nullptr,
2226 const std::vector<flatbuffers::Offset<tflite::TensorGroup>> *input_tensor_groups = nullptr,
2227 const std::vector<flatbuffers::Offset<tflite::TensorGroup>> *output_tensor_groups = nullptr) {
2228 auto name__ = name ? _fbb.CreateString(name) : 0;
2229 auto description__ = description ? _fbb.CreateString(description) : 0;
2230 auto input_tensor_metadata__ = input_tensor_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMetadata>>(*input_tensor_metadata) : 0;
2231 auto output_tensor_metadata__ = output_tensor_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMetadata>>(*output_tensor_metadata) : 0;
2232 auto associated_files__ = associated_files ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>>(*associated_files) : 0;
2233 auto input_process_units__ = input_process_units ? _fbb.CreateVector<flatbuffers::Offset<tflite::ProcessUnit>>(*input_process_units) : 0;
2234 auto output_process_units__ = output_process_units ? _fbb.CreateVector<flatbuffers::Offset<tflite::ProcessUnit>>(*output_process_units) : 0;
2235 auto input_tensor_groups__ = input_tensor_groups ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorGroup>>(*input_tensor_groups) : 0;
2236 auto output_tensor_groups__ = output_tensor_groups ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorGroup>>(*output_tensor_groups) : 0;
2237 return tflite::CreateSubGraphMetadata(
2238 _fbb,
2239 name__,
2240 description__,
2241 input_tensor_metadata__,
2242 output_tensor_metadata__,
2243 associated_files__,
2244 input_process_units__,
2245 output_process_units__,
2246 input_tensor_groups__,
2247 output_tensor_groups__);
2248 }
2249
2250 flatbuffers::Offset<SubGraphMetadata> CreateSubGraphMetadata(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2251
2252 struct ModelMetadataT : public flatbuffers::NativeTable {
2253 typedef ModelMetadata TableType;
2254 std::string name{};
2255 std::string description{};
2256 std::string version{};
2257 std::vector<std::unique_ptr<tflite::SubGraphMetadataT>> subgraph_metadata{};
2258 std::string author{};
2259 std::string license{};
2260 std::vector<std::unique_ptr<tflite::AssociatedFileT>> associated_files{};
2261 std::string min_parser_version{};
2262 ModelMetadataT() = default;
2263 ModelMetadataT(const ModelMetadataT &o);
2264 ModelMetadataT(ModelMetadataT&&) FLATBUFFERS_NOEXCEPT = default;
2265 ModelMetadataT &operator=(ModelMetadataT o) FLATBUFFERS_NOEXCEPT;
2266 };
2267
2268 struct ModelMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2269 typedef ModelMetadataT NativeTableType;
2270 typedef ModelMetadataBuilder Builder;
2271 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2272 VT_NAME = 4,
2273 VT_DESCRIPTION = 6,
2274 VT_VERSION = 8,
2275 VT_SUBGRAPH_METADATA = 10,
2276 VT_AUTHOR = 12,
2277 VT_LICENSE = 14,
2278 VT_ASSOCIATED_FILES = 16,
2279 VT_MIN_PARSER_VERSION = 18
2280 };
2281 const flatbuffers::String *name() const {
2282 return GetPointer<const flatbuffers::String *>(VT_NAME);
2283 }
2284 const flatbuffers::String *description() const {
2285 return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
2286 }
2287 const flatbuffers::String *version() const {
2288 return GetPointer<const flatbuffers::String *>(VT_VERSION);
2289 }
2290 const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraphMetadata>> *subgraph_metadata() const {
2291 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraphMetadata>> *>(VT_SUBGRAPH_METADATA);
2292 }
2293 const flatbuffers::String *author() const {
2294 return GetPointer<const flatbuffers::String *>(VT_AUTHOR);
2295 }
2296 const flatbuffers::String *license() const {
2297 return GetPointer<const flatbuffers::String *>(VT_LICENSE);
2298 }
2299 const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *associated_files() const {
2300 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>> *>(VT_ASSOCIATED_FILES);
2301 }
2302 const flatbuffers::String *min_parser_version() const {
2303 return GetPointer<const flatbuffers::String *>(VT_MIN_PARSER_VERSION);
2304 }
2305 bool Verify(flatbuffers::Verifier &verifier) const {
2306 return VerifyTableStart(verifier) &&
2307 VerifyOffset(verifier, VT_NAME) &&
2308 verifier.VerifyString(name()) &&
2309 VerifyOffset(verifier, VT_DESCRIPTION) &&
2310 verifier.VerifyString(description()) &&
2311 VerifyOffset(verifier, VT_VERSION) &&
2312 verifier.VerifyString(version()) &&
2313 VerifyOffset(verifier, VT_SUBGRAPH_METADATA) &&
2314 verifier.VerifyVector(subgraph_metadata()) &&
2315 verifier.VerifyVectorOfTables(subgraph_metadata()) &&
2316 VerifyOffset(verifier, VT_AUTHOR) &&
2317 verifier.VerifyString(author()) &&
2318 VerifyOffset(verifier, VT_LICENSE) &&
2319 verifier.VerifyString(license()) &&
2320 VerifyOffset(verifier, VT_ASSOCIATED_FILES) &&
2321 verifier.VerifyVector(associated_files()) &&
2322 verifier.VerifyVectorOfTables(associated_files()) &&
2323 VerifyOffset(verifier, VT_MIN_PARSER_VERSION) &&
2324 verifier.VerifyString(min_parser_version()) &&
2325 verifier.EndTable();
2326 }
2327 ModelMetadataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2328 void UnPackTo(ModelMetadataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
2329 static flatbuffers::Offset<ModelMetadata> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2330 };
2331
2332 struct ModelMetadataBuilder {
2333 typedef ModelMetadata Table;
2334 flatbuffers::FlatBufferBuilder &fbb_;
2335 flatbuffers::uoffset_t start_;
2336 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
2337 fbb_.AddOffset(ModelMetadata::VT_NAME, name);
2338 }
2339 void add_description(flatbuffers::Offset<flatbuffers::String> description) {
2340 fbb_.AddOffset(ModelMetadata::VT_DESCRIPTION, description);
2341 }
2342 void add_version(flatbuffers::Offset<flatbuffers::String> version) {
2343 fbb_.AddOffset(ModelMetadata::VT_VERSION, version);
2344 }
2345 void add_subgraph_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraphMetadata>>> subgraph_metadata) {
2346 fbb_.AddOffset(ModelMetadata::VT_SUBGRAPH_METADATA, subgraph_metadata);
2347 }
2348 void add_author(flatbuffers::Offset<flatbuffers::String> author) {
2349 fbb_.AddOffset(ModelMetadata::VT_AUTHOR, author);
2350 }
2351 void add_license(flatbuffers::Offset<flatbuffers::String> license) {
2352 fbb_.AddOffset(ModelMetadata::VT_LICENSE, license);
2353 }
2354 void add_associated_files(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> associated_files) {
2355 fbb_.AddOffset(ModelMetadata::VT_ASSOCIATED_FILES, associated_files);
2356 }
2357 void add_min_parser_version(flatbuffers::Offset<flatbuffers::String> min_parser_version) {
2358 fbb_.AddOffset(ModelMetadata::VT_MIN_PARSER_VERSION, min_parser_version);
2359 }
2360 explicit ModelMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2361 : fbb_(_fbb) {
2362 start_ = fbb_.StartTable();
2363 }
2364 flatbuffers::Offset<ModelMetadata> Finish() {
2365 const auto end = fbb_.EndTable(start_);
2366 auto o = flatbuffers::Offset<ModelMetadata>(end);
2367 return o;
2368 }
2369 };
2370
2371 inline flatbuffers::Offset<ModelMetadata> CreateModelMetadata(
2372 flatbuffers::FlatBufferBuilder &_fbb,
2373 flatbuffers::Offset<flatbuffers::String> name = 0,
2374 flatbuffers::Offset<flatbuffers::String> description = 0,
2375 flatbuffers::Offset<flatbuffers::String> version = 0,
2376 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::SubGraphMetadata>>> subgraph_metadata = 0,
2377 flatbuffers::Offset<flatbuffers::String> author = 0,
2378 flatbuffers::Offset<flatbuffers::String> license = 0,
2379 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::AssociatedFile>>> associated_files = 0,
2380 flatbuffers::Offset<flatbuffers::String> min_parser_version = 0) {
2381 ModelMetadataBuilder builder_(_fbb);
2382 builder_.add_min_parser_version(min_parser_version);
2383 builder_.add_associated_files(associated_files);
2384 builder_.add_license(license);
2385 builder_.add_author(author);
2386 builder_.add_subgraph_metadata(subgraph_metadata);
2387 builder_.add_version(version);
2388 builder_.add_description(description);
2389 builder_.add_name(name);
2390 return builder_.Finish();
2391 }
2392
2393 inline flatbuffers::Offset<ModelMetadata> CreateModelMetadataDirect(
2394 flatbuffers::FlatBufferBuilder &_fbb,
2395 const char *name = nullptr,
2396 const char *description = nullptr,
2397 const char *version = nullptr,
2398 const std::vector<flatbuffers::Offset<tflite::SubGraphMetadata>> *subgraph_metadata = nullptr,
2399 const char *author = nullptr,
2400 const char *license = nullptr,
2401 const std::vector<flatbuffers::Offset<tflite::AssociatedFile>> *associated_files = nullptr,
2402 const char *min_parser_version = nullptr) {
2403 auto name__ = name ? _fbb.CreateString(name) : 0;
2404 auto description__ = description ? _fbb.CreateString(description) : 0;
2405 auto version__ = version ? _fbb.CreateString(version) : 0;
2406 auto subgraph_metadata__ = subgraph_metadata ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraphMetadata>>(*subgraph_metadata) : 0;
2407 auto author__ = author ? _fbb.CreateString(author) : 0;
2408 auto license__ = license ? _fbb.CreateString(license) : 0;
2409 auto associated_files__ = associated_files ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>>(*associated_files) : 0;
2410 auto min_parser_version__ = min_parser_version ? _fbb.CreateString(min_parser_version) : 0;
2411 return tflite::CreateModelMetadata(
2412 _fbb,
2413 name__,
2414 description__,
2415 version__,
2416 subgraph_metadata__,
2417 author__,
2418 license__,
2419 associated_files__,
2420 min_parser_version__);
2421 }
2422
2423 flatbuffers::Offset<ModelMetadata> CreateModelMetadata(flatbuffers::FlatBufferBuilder &_fbb, const ModelMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
2424
2425 inline AssociatedFileT *AssociatedFile::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2426 auto _o = std::unique_ptr<AssociatedFileT>(new AssociatedFileT());
2427 UnPackTo(_o.get(), _resolver);
2428 return _o.release();
2429 }
2430
2431 inline void AssociatedFile::UnPackTo(AssociatedFileT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2432 (void)_o;
2433 (void)_resolver;
2434 { auto _e = name(); if (_e) _o->name = _e->str(); }
2435 { auto _e = description(); if (_e) _o->description = _e->str(); }
2436 { auto _e = type(); _o->type = _e; }
2437 { auto _e = locale(); if (_e) _o->locale = _e->str(); }
2438 { auto _e = version(); if (_e) _o->version = _e->str(); }
2439 }
2440
2441 inline flatbuffers::Offset<AssociatedFile> AssociatedFile::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AssociatedFileT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2442 return CreateAssociatedFile(_fbb, _o, _rehasher);
2443 }
2444
2445 inline flatbuffers::Offset<AssociatedFile> CreateAssociatedFile(flatbuffers::FlatBufferBuilder &_fbb, const AssociatedFileT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2446 (void)_rehasher;
2447 (void)_o;
2448 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AssociatedFileT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2449 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
2450 auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
2451 auto _type = _o->type;
2452 auto _locale = _o->locale.empty() ? 0 : _fbb.CreateString(_o->locale);
2453 auto _version = _o->version.empty() ? 0 : _fbb.CreateString(_o->version);
2454 return tflite::CreateAssociatedFile(
2455 _fbb,
2456 _name,
2457 _description,
2458 _type,
2459 _locale,
2460 _version);
2461 }
2462
2463 inline FeaturePropertiesT *FeatureProperties::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2464 auto _o = std::unique_ptr<FeaturePropertiesT>(new FeaturePropertiesT());
2465 UnPackTo(_o.get(), _resolver);
2466 return _o.release();
2467 }
2468
2469 inline void FeatureProperties::UnPackTo(FeaturePropertiesT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2470 (void)_o;
2471 (void)_resolver;
2472 }
2473
2474 inline flatbuffers::Offset<FeatureProperties> FeatureProperties::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FeaturePropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2475 return CreateFeatureProperties(_fbb, _o, _rehasher);
2476 }
2477
2478 inline flatbuffers::Offset<FeatureProperties> CreateFeatureProperties(flatbuffers::FlatBufferBuilder &_fbb, const FeaturePropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2479 (void)_rehasher;
2480 (void)_o;
2481 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FeaturePropertiesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2482 return tflite::CreateFeatureProperties(
2483 _fbb);
2484 }
2485
2486 inline ImageSizeT *ImageSize::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2487 auto _o = std::unique_ptr<ImageSizeT>(new ImageSizeT());
2488 UnPackTo(_o.get(), _resolver);
2489 return _o.release();
2490 }
2491
2492 inline void ImageSize::UnPackTo(ImageSizeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2493 (void)_o;
2494 (void)_resolver;
2495 { auto _e = width(); _o->width = _e; }
2496 { auto _e = height(); _o->height = _e; }
2497 }
2498
2499 inline flatbuffers::Offset<ImageSize> ImageSize::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ImageSizeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2500 return CreateImageSize(_fbb, _o, _rehasher);
2501 }
2502
2503 inline flatbuffers::Offset<ImageSize> CreateImageSize(flatbuffers::FlatBufferBuilder &_fbb, const ImageSizeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2504 (void)_rehasher;
2505 (void)_o;
2506 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ImageSizeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2507 auto _width = _o->width;
2508 auto _height = _o->height;
2509 return tflite::CreateImageSize(
2510 _fbb,
2511 _width,
2512 _height);
2513 }
2514
2515 inline ImagePropertiesT::ImagePropertiesT(const ImagePropertiesT &o)
2516 : color_space(o.color_space),
2517 default_size((o.default_size) ? new tflite::ImageSizeT(*o.default_size) : nullptr) {
2518 }
2519
2520 inline ImagePropertiesT &ImagePropertiesT::operator=(ImagePropertiesT o) FLATBUFFERS_NOEXCEPT {
2521 std::swap(color_space, o.color_space);
2522 std::swap(default_size, o.default_size);
2523 return *this;
2524 }
2525
2526 inline ImagePropertiesT *ImageProperties::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2527 auto _o = std::unique_ptr<ImagePropertiesT>(new ImagePropertiesT());
2528 UnPackTo(_o.get(), _resolver);
2529 return _o.release();
2530 }
2531
2532 inline void ImageProperties::UnPackTo(ImagePropertiesT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2533 (void)_o;
2534 (void)_resolver;
2535 { auto _e = color_space(); _o->color_space = _e; }
2536 { auto _e = default_size(); if (_e) _o->default_size = std::unique_ptr<tflite::ImageSizeT>(_e->UnPack(_resolver)); }
2537 }
2538
2539 inline flatbuffers::Offset<ImageProperties> ImageProperties::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ImagePropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2540 return CreateImageProperties(_fbb, _o, _rehasher);
2541 }
2542
2543 inline flatbuffers::Offset<ImageProperties> CreateImageProperties(flatbuffers::FlatBufferBuilder &_fbb, const ImagePropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2544 (void)_rehasher;
2545 (void)_o;
2546 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ImagePropertiesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2547 auto _color_space = _o->color_space;
2548 auto _default_size = _o->default_size ? CreateImageSize(_fbb, _o->default_size.get(), _rehasher) : 0;
2549 return tflite::CreateImageProperties(
2550 _fbb,
2551 _color_space,
2552 _default_size);
2553 }
2554
2555 inline AudioPropertiesT *AudioProperties::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2556 auto _o = std::unique_ptr<AudioPropertiesT>(new AudioPropertiesT());
2557 UnPackTo(_o.get(), _resolver);
2558 return _o.release();
2559 }
2560
2561 inline void AudioProperties::UnPackTo(AudioPropertiesT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2562 (void)_o;
2563 (void)_resolver;
2564 { auto _e = sample_rate(); _o->sample_rate = _e; }
2565 { auto _e = channels(); _o->channels = _e; }
2566 }
2567
2568 inline flatbuffers::Offset<AudioProperties> AudioProperties::Pack(flatbuffers::FlatBufferBuilder &_fbb, const AudioPropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2569 return CreateAudioProperties(_fbb, _o, _rehasher);
2570 }
2571
2572 inline flatbuffers::Offset<AudioProperties> CreateAudioProperties(flatbuffers::FlatBufferBuilder &_fbb, const AudioPropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2573 (void)_rehasher;
2574 (void)_o;
2575 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const AudioPropertiesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2576 auto _sample_rate = _o->sample_rate;
2577 auto _channels = _o->channels;
2578 return tflite::CreateAudioProperties(
2579 _fbb,
2580 _sample_rate,
2581 _channels);
2582 }
2583
2584 inline BoundingBoxPropertiesT *BoundingBoxProperties::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2585 auto _o = std::unique_ptr<BoundingBoxPropertiesT>(new BoundingBoxPropertiesT());
2586 UnPackTo(_o.get(), _resolver);
2587 return _o.release();
2588 }
2589
2590 inline void BoundingBoxProperties::UnPackTo(BoundingBoxPropertiesT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2591 (void)_o;
2592 (void)_resolver;
2593 { auto _e = index(); if (_e) { _o->index.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->index[_i] = _e->Get(_i); } } }
2594 { auto _e = type(); _o->type = _e; }
2595 { auto _e = coordinate_type(); _o->coordinate_type = _e; }
2596 }
2597
2598 inline flatbuffers::Offset<BoundingBoxProperties> BoundingBoxProperties::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BoundingBoxPropertiesT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2599 return CreateBoundingBoxProperties(_fbb, _o, _rehasher);
2600 }
2601
2602 inline flatbuffers::Offset<BoundingBoxProperties> CreateBoundingBoxProperties(flatbuffers::FlatBufferBuilder &_fbb, const BoundingBoxPropertiesT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2603 (void)_rehasher;
2604 (void)_o;
2605 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BoundingBoxPropertiesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2606 auto _index = _o->index.size() ? _fbb.CreateVector(_o->index) : 0;
2607 auto _type = _o->type;
2608 auto _coordinate_type = _o->coordinate_type;
2609 return tflite::CreateBoundingBoxProperties(
2610 _fbb,
2611 _index,
2612 _type,
2613 _coordinate_type);
2614 }
2615
2616 inline ValueRangeT *ValueRange::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2617 auto _o = std::unique_ptr<ValueRangeT>(new ValueRangeT());
2618 UnPackTo(_o.get(), _resolver);
2619 return _o.release();
2620 }
2621
2622 inline void ValueRange::UnPackTo(ValueRangeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2623 (void)_o;
2624 (void)_resolver;
2625 { auto _e = min(); _o->min = _e; }
2626 { auto _e = max(); _o->max = _e; }
2627 }
2628
2629 inline flatbuffers::Offset<ValueRange> ValueRange::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ValueRangeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2630 return CreateValueRange(_fbb, _o, _rehasher);
2631 }
2632
2633 inline flatbuffers::Offset<ValueRange> CreateValueRange(flatbuffers::FlatBufferBuilder &_fbb, const ValueRangeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2634 (void)_rehasher;
2635 (void)_o;
2636 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ValueRangeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2637 auto _min = _o->min;
2638 auto _max = _o->max;
2639 return tflite::CreateValueRange(
2640 _fbb,
2641 _min,
2642 _max);
2643 }
2644
2645 inline ContentT::ContentT(const ContentT &o)
2646 : content_properties(o.content_properties),
2647 range((o.range) ? new tflite::ValueRangeT(*o.range) : nullptr) {
2648 }
2649
2650 inline ContentT &ContentT::operator=(ContentT o) FLATBUFFERS_NOEXCEPT {
2651 std::swap(content_properties, o.content_properties);
2652 std::swap(range, o.range);
2653 return *this;
2654 }
2655
2656 inline ContentT *Content::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2657 auto _o = std::unique_ptr<ContentT>(new ContentT());
2658 UnPackTo(_o.get(), _resolver);
2659 return _o.release();
2660 }
2661
2662 inline void Content::UnPackTo(ContentT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2663 (void)_o;
2664 (void)_resolver;
2665 { auto _e = content_properties_type(); _o->content_properties.type = _e; }
2666 { auto _e = content_properties(); if (_e) _o->content_properties.value = tflite::ContentPropertiesUnion::UnPack(_e, content_properties_type(), _resolver); }
2667 { auto _e = range(); if (_e) _o->range = std::unique_ptr<tflite::ValueRangeT>(_e->UnPack(_resolver)); }
2668 }
2669
2670 inline flatbuffers::Offset<Content> Content::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ContentT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2671 return CreateContent(_fbb, _o, _rehasher);
2672 }
2673
2674 inline flatbuffers::Offset<Content> CreateContent(flatbuffers::FlatBufferBuilder &_fbb, const ContentT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2675 (void)_rehasher;
2676 (void)_o;
2677 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ContentT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2678 auto _content_properties_type = _o->content_properties.type;
2679 auto _content_properties = _o->content_properties.Pack(_fbb);
2680 auto _range = _o->range ? CreateValueRange(_fbb, _o->range.get(), _rehasher) : 0;
2681 return tflite::CreateContent(
2682 _fbb,
2683 _content_properties_type,
2684 _content_properties,
2685 _range);
2686 }
2687
2688 inline NormalizationOptionsT *NormalizationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2689 auto _o = std::unique_ptr<NormalizationOptionsT>(new NormalizationOptionsT());
2690 UnPackTo(_o.get(), _resolver);
2691 return _o.release();
2692 }
2693
2694 inline void NormalizationOptions::UnPackTo(NormalizationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2695 (void)_o;
2696 (void)_resolver;
2697 { auto _e = mean(); if (_e) { _o->mean.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mean[_i] = _e->Get(_i); } } }
2698 { auto _e = std(); if (_e) { _o->std.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->std[_i] = _e->Get(_i); } } }
2699 }
2700
2701 inline flatbuffers::Offset<NormalizationOptions> NormalizationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NormalizationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2702 return CreateNormalizationOptions(_fbb, _o, _rehasher);
2703 }
2704
2705 inline flatbuffers::Offset<NormalizationOptions> CreateNormalizationOptions(flatbuffers::FlatBufferBuilder &_fbb, const NormalizationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2706 (void)_rehasher;
2707 (void)_o;
2708 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const NormalizationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2709 auto _mean = _o->mean.size() ? _fbb.CreateVector(_o->mean) : 0;
2710 auto _std = _o->std.size() ? _fbb.CreateVector(_o->std) : 0;
2711 return tflite::CreateNormalizationOptions(
2712 _fbb,
2713 _mean,
2714 _std);
2715 }
2716
2717 inline ScoreCalibrationOptionsT *ScoreCalibrationOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2718 auto _o = std::unique_ptr<ScoreCalibrationOptionsT>(new ScoreCalibrationOptionsT());
2719 UnPackTo(_o.get(), _resolver);
2720 return _o.release();
2721 }
2722
2723 inline void ScoreCalibrationOptions::UnPackTo(ScoreCalibrationOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2724 (void)_o;
2725 (void)_resolver;
2726 { auto _e = score_transformation(); _o->score_transformation = _e; }
2727 { auto _e = default_score(); _o->default_score = _e; }
2728 }
2729
2730 inline flatbuffers::Offset<ScoreCalibrationOptions> ScoreCalibrationOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScoreCalibrationOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2731 return CreateScoreCalibrationOptions(_fbb, _o, _rehasher);
2732 }
2733
2734 inline flatbuffers::Offset<ScoreCalibrationOptions> CreateScoreCalibrationOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScoreCalibrationOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2735 (void)_rehasher;
2736 (void)_o;
2737 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScoreCalibrationOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2738 auto _score_transformation = _o->score_transformation;
2739 auto _default_score = _o->default_score;
2740 return tflite::CreateScoreCalibrationOptions(
2741 _fbb,
2742 _score_transformation,
2743 _default_score);
2744 }
2745
2746 inline ScoreThresholdingOptionsT *ScoreThresholdingOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2747 auto _o = std::unique_ptr<ScoreThresholdingOptionsT>(new ScoreThresholdingOptionsT());
2748 UnPackTo(_o.get(), _resolver);
2749 return _o.release();
2750 }
2751
2752 inline void ScoreThresholdingOptions::UnPackTo(ScoreThresholdingOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2753 (void)_o;
2754 (void)_resolver;
2755 { auto _e = global_score_threshold(); _o->global_score_threshold = _e; }
2756 }
2757
2758 inline flatbuffers::Offset<ScoreThresholdingOptions> ScoreThresholdingOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ScoreThresholdingOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2759 return CreateScoreThresholdingOptions(_fbb, _o, _rehasher);
2760 }
2761
2762 inline flatbuffers::Offset<ScoreThresholdingOptions> CreateScoreThresholdingOptions(flatbuffers::FlatBufferBuilder &_fbb, const ScoreThresholdingOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2763 (void)_rehasher;
2764 (void)_o;
2765 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ScoreThresholdingOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2766 auto _global_score_threshold = _o->global_score_threshold;
2767 return tflite::CreateScoreThresholdingOptions(
2768 _fbb,
2769 _global_score_threshold);
2770 }
2771
2772 inline BertTokenizerOptionsT::BertTokenizerOptionsT(const BertTokenizerOptionsT &o) {
2773 vocab_file.reserve(o.vocab_file.size());
2774 for (const auto &vocab_file_ : o.vocab_file) { vocab_file.emplace_back((vocab_file_) ? new tflite::AssociatedFileT(*vocab_file_) : nullptr); }
2775 }
2776
2777 inline BertTokenizerOptionsT &BertTokenizerOptionsT::operator=(BertTokenizerOptionsT o) FLATBUFFERS_NOEXCEPT {
2778 std::swap(vocab_file, o.vocab_file);
2779 return *this;
2780 }
2781
2782 inline BertTokenizerOptionsT *BertTokenizerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2783 auto _o = std::unique_ptr<BertTokenizerOptionsT>(new BertTokenizerOptionsT());
2784 UnPackTo(_o.get(), _resolver);
2785 return _o.release();
2786 }
2787
2788 inline void BertTokenizerOptions::UnPackTo(BertTokenizerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2789 (void)_o;
2790 (void)_resolver;
2791 { auto _e = vocab_file(); if (_e) { _o->vocab_file.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vocab_file[_i] = std::unique_ptr<tflite::AssociatedFileT>(_e->Get(_i)->UnPack(_resolver)); } } }
2792 }
2793
2794 inline flatbuffers::Offset<BertTokenizerOptions> BertTokenizerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const BertTokenizerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2795 return CreateBertTokenizerOptions(_fbb, _o, _rehasher);
2796 }
2797
2798 inline flatbuffers::Offset<BertTokenizerOptions> CreateBertTokenizerOptions(flatbuffers::FlatBufferBuilder &_fbb, const BertTokenizerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2799 (void)_rehasher;
2800 (void)_o;
2801 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const BertTokenizerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2802 auto _vocab_file = _o->vocab_file.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>> (_o->vocab_file.size(), [](size_t i, _VectorArgs *__va) { return CreateAssociatedFile(*__va->__fbb, __va->__o->vocab_file[i].get(), __va->__rehasher); }, &_va ) : 0;
2803 return tflite::CreateBertTokenizerOptions(
2804 _fbb,
2805 _vocab_file);
2806 }
2807
2808 inline SentencePieceTokenizerOptionsT::SentencePieceTokenizerOptionsT(const SentencePieceTokenizerOptionsT &o) {
2809 sentencePiece_model.reserve(o.sentencePiece_model.size());
2810 for (const auto &sentencePiece_model_ : o.sentencePiece_model) { sentencePiece_model.emplace_back((sentencePiece_model_) ? new tflite::AssociatedFileT(*sentencePiece_model_) : nullptr); }
2811 vocab_file.reserve(o.vocab_file.size());
2812 for (const auto &vocab_file_ : o.vocab_file) { vocab_file.emplace_back((vocab_file_) ? new tflite::AssociatedFileT(*vocab_file_) : nullptr); }
2813 }
2814
2815 inline SentencePieceTokenizerOptionsT &SentencePieceTokenizerOptionsT::operator=(SentencePieceTokenizerOptionsT o) FLATBUFFERS_NOEXCEPT {
2816 std::swap(sentencePiece_model, o.sentencePiece_model);
2817 std::swap(vocab_file, o.vocab_file);
2818 return *this;
2819 }
2820
2821 inline SentencePieceTokenizerOptionsT *SentencePieceTokenizerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2822 auto _o = std::unique_ptr<SentencePieceTokenizerOptionsT>(new SentencePieceTokenizerOptionsT());
2823 UnPackTo(_o.get(), _resolver);
2824 return _o.release();
2825 }
2826
2827 inline void SentencePieceTokenizerOptions::UnPackTo(SentencePieceTokenizerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2828 (void)_o;
2829 (void)_resolver;
2830 { auto _e = sentencePiece_model(); if (_e) { _o->sentencePiece_model.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->sentencePiece_model[_i] = std::unique_ptr<tflite::AssociatedFileT>(_e->Get(_i)->UnPack(_resolver)); } } }
2831 { auto _e = vocab_file(); if (_e) { _o->vocab_file.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vocab_file[_i] = std::unique_ptr<tflite::AssociatedFileT>(_e->Get(_i)->UnPack(_resolver)); } } }
2832 }
2833
2834 inline flatbuffers::Offset<SentencePieceTokenizerOptions> SentencePieceTokenizerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SentencePieceTokenizerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2835 return CreateSentencePieceTokenizerOptions(_fbb, _o, _rehasher);
2836 }
2837
2838 inline flatbuffers::Offset<SentencePieceTokenizerOptions> CreateSentencePieceTokenizerOptions(flatbuffers::FlatBufferBuilder &_fbb, const SentencePieceTokenizerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2839 (void)_rehasher;
2840 (void)_o;
2841 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SentencePieceTokenizerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2842 auto _sentencePiece_model = _o->sentencePiece_model.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>> (_o->sentencePiece_model.size(), [](size_t i, _VectorArgs *__va) { return CreateAssociatedFile(*__va->__fbb, __va->__o->sentencePiece_model[i].get(), __va->__rehasher); }, &_va ) : 0;
2843 auto _vocab_file = _o->vocab_file.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>> (_o->vocab_file.size(), [](size_t i, _VectorArgs *__va) { return CreateAssociatedFile(*__va->__fbb, __va->__o->vocab_file[i].get(), __va->__rehasher); }, &_va ) : 0;
2844 return tflite::CreateSentencePieceTokenizerOptions(
2845 _fbb,
2846 _sentencePiece_model,
2847 _vocab_file);
2848 }
2849
2850 inline RegexTokenizerOptionsT::RegexTokenizerOptionsT(const RegexTokenizerOptionsT &o)
2851 : delim_regex_pattern(o.delim_regex_pattern) {
2852 vocab_file.reserve(o.vocab_file.size());
2853 for (const auto &vocab_file_ : o.vocab_file) { vocab_file.emplace_back((vocab_file_) ? new tflite::AssociatedFileT(*vocab_file_) : nullptr); }
2854 }
2855
2856 inline RegexTokenizerOptionsT &RegexTokenizerOptionsT::operator=(RegexTokenizerOptionsT o) FLATBUFFERS_NOEXCEPT {
2857 std::swap(delim_regex_pattern, o.delim_regex_pattern);
2858 std::swap(vocab_file, o.vocab_file);
2859 return *this;
2860 }
2861
2862 inline RegexTokenizerOptionsT *RegexTokenizerOptions::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2863 auto _o = std::unique_ptr<RegexTokenizerOptionsT>(new RegexTokenizerOptionsT());
2864 UnPackTo(_o.get(), _resolver);
2865 return _o.release();
2866 }
2867
2868 inline void RegexTokenizerOptions::UnPackTo(RegexTokenizerOptionsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2869 (void)_o;
2870 (void)_resolver;
2871 { auto _e = delim_regex_pattern(); if (_e) _o->delim_regex_pattern = _e->str(); }
2872 { auto _e = vocab_file(); if (_e) { _o->vocab_file.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vocab_file[_i] = std::unique_ptr<tflite::AssociatedFileT>(_e->Get(_i)->UnPack(_resolver)); } } }
2873 }
2874
2875 inline flatbuffers::Offset<RegexTokenizerOptions> RegexTokenizerOptions::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RegexTokenizerOptionsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2876 return CreateRegexTokenizerOptions(_fbb, _o, _rehasher);
2877 }
2878
2879 inline flatbuffers::Offset<RegexTokenizerOptions> CreateRegexTokenizerOptions(flatbuffers::FlatBufferBuilder &_fbb, const RegexTokenizerOptionsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2880 (void)_rehasher;
2881 (void)_o;
2882 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RegexTokenizerOptionsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2883 auto _delim_regex_pattern = _o->delim_regex_pattern.empty() ? 0 : _fbb.CreateString(_o->delim_regex_pattern);
2884 auto _vocab_file = _o->vocab_file.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>> (_o->vocab_file.size(), [](size_t i, _VectorArgs *__va) { return CreateAssociatedFile(*__va->__fbb, __va->__o->vocab_file[i].get(), __va->__rehasher); }, &_va ) : 0;
2885 return tflite::CreateRegexTokenizerOptions(
2886 _fbb,
2887 _delim_regex_pattern,
2888 _vocab_file);
2889 }
2890
2891 inline ProcessUnitT *ProcessUnit::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2892 auto _o = std::unique_ptr<ProcessUnitT>(new ProcessUnitT());
2893 UnPackTo(_o.get(), _resolver);
2894 return _o.release();
2895 }
2896
2897 inline void ProcessUnit::UnPackTo(ProcessUnitT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2898 (void)_o;
2899 (void)_resolver;
2900 { auto _e = options_type(); _o->options.type = _e; }
2901 { auto _e = options(); if (_e) _o->options.value = tflite::ProcessUnitOptionsUnion::UnPack(_e, options_type(), _resolver); }
2902 }
2903
2904 inline flatbuffers::Offset<ProcessUnit> ProcessUnit::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ProcessUnitT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2905 return CreateProcessUnit(_fbb, _o, _rehasher);
2906 }
2907
2908 inline flatbuffers::Offset<ProcessUnit> CreateProcessUnit(flatbuffers::FlatBufferBuilder &_fbb, const ProcessUnitT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2909 (void)_rehasher;
2910 (void)_o;
2911 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ProcessUnitT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2912 auto _options_type = _o->options.type;
2913 auto _options = _o->options.Pack(_fbb);
2914 return tflite::CreateProcessUnit(
2915 _fbb,
2916 _options_type,
2917 _options);
2918 }
2919
2920 inline StatsT *Stats::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2921 auto _o = std::unique_ptr<StatsT>(new StatsT());
2922 UnPackTo(_o.get(), _resolver);
2923 return _o.release();
2924 }
2925
2926 inline void Stats::UnPackTo(StatsT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2927 (void)_o;
2928 (void)_resolver;
2929 { 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); } } }
2930 { 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); } } }
2931 }
2932
2933 inline flatbuffers::Offset<Stats> Stats::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatsT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2934 return CreateStats(_fbb, _o, _rehasher);
2935 }
2936
2937 inline flatbuffers::Offset<Stats> CreateStats(flatbuffers::FlatBufferBuilder &_fbb, const StatsT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2938 (void)_rehasher;
2939 (void)_o;
2940 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StatsT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2941 auto _max = _o->max.size() ? _fbb.CreateVector(_o->max) : 0;
2942 auto _min = _o->min.size() ? _fbb.CreateVector(_o->min) : 0;
2943 return tflite::CreateStats(
2944 _fbb,
2945 _max,
2946 _min);
2947 }
2948
2949 inline TensorGroupT *TensorGroup::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2950 auto _o = std::unique_ptr<TensorGroupT>(new TensorGroupT());
2951 UnPackTo(_o.get(), _resolver);
2952 return _o.release();
2953 }
2954
2955 inline void TensorGroup::UnPackTo(TensorGroupT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2956 (void)_o;
2957 (void)_resolver;
2958 { auto _e = name(); if (_e) _o->name = _e->str(); }
2959 { auto _e = tensor_names(); if (_e) { _o->tensor_names.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->tensor_names[_i] = _e->Get(_i)->str(); } } }
2960 }
2961
2962 inline flatbuffers::Offset<TensorGroup> TensorGroup::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorGroupT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2963 return CreateTensorGroup(_fbb, _o, _rehasher);
2964 }
2965
2966 inline flatbuffers::Offset<TensorGroup> CreateTensorGroup(flatbuffers::FlatBufferBuilder &_fbb, const TensorGroupT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2967 (void)_rehasher;
2968 (void)_o;
2969 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorGroupT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
2970 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
2971 auto _tensor_names = _o->tensor_names.size() ? _fbb.CreateVectorOfStrings(_o->tensor_names) : 0;
2972 return tflite::CreateTensorGroup(
2973 _fbb,
2974 _name,
2975 _tensor_names);
2976 }
2977
2978 inline TensorMetadataT::TensorMetadataT(const TensorMetadataT &o)
2979 : name(o.name),
2980 description(o.description),
2981 dimension_names(o.dimension_names),
2982 content((o.content) ? new tflite::ContentT(*o.content) : nullptr),
2983 stats((o.stats) ? new tflite::StatsT(*o.stats) : nullptr) {
2984 process_units.reserve(o.process_units.size());
2985 for (const auto &process_units_ : o.process_units) { process_units.emplace_back((process_units_) ? new tflite::ProcessUnitT(*process_units_) : nullptr); }
2986 associated_files.reserve(o.associated_files.size());
2987 for (const auto &associated_files_ : o.associated_files) { associated_files.emplace_back((associated_files_) ? new tflite::AssociatedFileT(*associated_files_) : nullptr); }
2988 }
2989
2990 inline TensorMetadataT &TensorMetadataT::operator=(TensorMetadataT o) FLATBUFFERS_NOEXCEPT {
2991 std::swap(name, o.name);
2992 std::swap(description, o.description);
2993 std::swap(dimension_names, o.dimension_names);
2994 std::swap(content, o.content);
2995 std::swap(process_units, o.process_units);
2996 std::swap(stats, o.stats);
2997 std::swap(associated_files, o.associated_files);
2998 return *this;
2999 }
3000
3001 inline TensorMetadataT *TensorMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
3002 auto _o = std::unique_ptr<TensorMetadataT>(new TensorMetadataT());
3003 UnPackTo(_o.get(), _resolver);
3004 return _o.release();
3005 }
3006
3007 inline void TensorMetadata::UnPackTo(TensorMetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
3008 (void)_o;
3009 (void)_resolver;
3010 { auto _e = name(); if (_e) _o->name = _e->str(); }
3011 { auto _e = description(); if (_e) _o->description = _e->str(); }
3012 { auto _e = dimension_names(); if (_e) { _o->dimension_names.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->dimension_names[_i] = _e->Get(_i)->str(); } } }
3013 { auto _e = content(); if (_e) _o->content = std::unique_ptr<tflite::ContentT>(_e->UnPack(_resolver)); }
3014 { auto _e = process_units(); if (_e) { _o->process_units.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->process_units[_i] = std::unique_ptr<tflite::ProcessUnitT>(_e->Get(_i)->UnPack(_resolver)); } } }
3015 { auto _e = stats(); if (_e) _o->stats = std::unique_ptr<tflite::StatsT>(_e->UnPack(_resolver)); }
3016 { auto _e = associated_files(); if (_e) { _o->associated_files.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->associated_files[_i] = std::unique_ptr<tflite::AssociatedFileT>(_e->Get(_i)->UnPack(_resolver)); } } }
3017 }
3018
3019 inline flatbuffers::Offset<TensorMetadata> TensorMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TensorMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
3020 return CreateTensorMetadata(_fbb, _o, _rehasher);
3021 }
3022
3023 inline flatbuffers::Offset<TensorMetadata> CreateTensorMetadata(flatbuffers::FlatBufferBuilder &_fbb, const TensorMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
3024 (void)_rehasher;
3025 (void)_o;
3026 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TensorMetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
3027 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
3028 auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
3029 auto _dimension_names = _o->dimension_names.size() ? _fbb.CreateVectorOfStrings(_o->dimension_names) : 0;
3030 auto _content = _o->content ? CreateContent(_fbb, _o->content.get(), _rehasher) : 0;
3031 auto _process_units = _o->process_units.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::ProcessUnit>> (_o->process_units.size(), [](size_t i, _VectorArgs *__va) { return CreateProcessUnit(*__va->__fbb, __va->__o->process_units[i].get(), __va->__rehasher); }, &_va ) : 0;
3032 auto _stats = _o->stats ? CreateStats(_fbb, _o->stats.get(), _rehasher) : 0;
3033 auto _associated_files = _o->associated_files.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>> (_o->associated_files.size(), [](size_t i, _VectorArgs *__va) { return CreateAssociatedFile(*__va->__fbb, __va->__o->associated_files[i].get(), __va->__rehasher); }, &_va ) : 0;
3034 return tflite::CreateTensorMetadata(
3035 _fbb,
3036 _name,
3037 _description,
3038 _dimension_names,
3039 _content,
3040 _process_units,
3041 _stats,
3042 _associated_files);
3043 }
3044
3045 inline SubGraphMetadataT::SubGraphMetadataT(const SubGraphMetadataT &o)
3046 : name(o.name),
3047 description(o.description) {
3048 input_tensor_metadata.reserve(o.input_tensor_metadata.size());
3049 for (const auto &input_tensor_metadata_ : o.input_tensor_metadata) { input_tensor_metadata.emplace_back((input_tensor_metadata_) ? new tflite::TensorMetadataT(*input_tensor_metadata_) : nullptr); }
3050 output_tensor_metadata.reserve(o.output_tensor_metadata.size());
3051 for (const auto &output_tensor_metadata_ : o.output_tensor_metadata) { output_tensor_metadata.emplace_back((output_tensor_metadata_) ? new tflite::TensorMetadataT(*output_tensor_metadata_) : nullptr); }
3052 associated_files.reserve(o.associated_files.size());
3053 for (const auto &associated_files_ : o.associated_files) { associated_files.emplace_back((associated_files_) ? new tflite::AssociatedFileT(*associated_files_) : nullptr); }
3054 input_process_units.reserve(o.input_process_units.size());
3055 for (const auto &input_process_units_ : o.input_process_units) { input_process_units.emplace_back((input_process_units_) ? new tflite::ProcessUnitT(*input_process_units_) : nullptr); }
3056 output_process_units.reserve(o.output_process_units.size());
3057 for (const auto &output_process_units_ : o.output_process_units) { output_process_units.emplace_back((output_process_units_) ? new tflite::ProcessUnitT(*output_process_units_) : nullptr); }
3058 input_tensor_groups.reserve(o.input_tensor_groups.size());
3059 for (const auto &input_tensor_groups_ : o.input_tensor_groups) { input_tensor_groups.emplace_back((input_tensor_groups_) ? new tflite::TensorGroupT(*input_tensor_groups_) : nullptr); }
3060 output_tensor_groups.reserve(o.output_tensor_groups.size());
3061 for (const auto &output_tensor_groups_ : o.output_tensor_groups) { output_tensor_groups.emplace_back((output_tensor_groups_) ? new tflite::TensorGroupT(*output_tensor_groups_) : nullptr); }
3062 }
3063
3064 inline SubGraphMetadataT &SubGraphMetadataT::operator=(SubGraphMetadataT o) FLATBUFFERS_NOEXCEPT {
3065 std::swap(name, o.name);
3066 std::swap(description, o.description);
3067 std::swap(input_tensor_metadata, o.input_tensor_metadata);
3068 std::swap(output_tensor_metadata, o.output_tensor_metadata);
3069 std::swap(associated_files, o.associated_files);
3070 std::swap(input_process_units, o.input_process_units);
3071 std::swap(output_process_units, o.output_process_units);
3072 std::swap(input_tensor_groups, o.input_tensor_groups);
3073 std::swap(output_tensor_groups, o.output_tensor_groups);
3074 return *this;
3075 }
3076
3077 inline SubGraphMetadataT *SubGraphMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
3078 auto _o = std::unique_ptr<SubGraphMetadataT>(new SubGraphMetadataT());
3079 UnPackTo(_o.get(), _resolver);
3080 return _o.release();
3081 }
3082
3083 inline void SubGraphMetadata::UnPackTo(SubGraphMetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
3084 (void)_o;
3085 (void)_resolver;
3086 { auto _e = name(); if (_e) _o->name = _e->str(); }
3087 { auto _e = description(); if (_e) _o->description = _e->str(); }
3088 { auto _e = input_tensor_metadata(); if (_e) { _o->input_tensor_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->input_tensor_metadata[_i] = std::unique_ptr<tflite::TensorMetadataT>(_e->Get(_i)->UnPack(_resolver)); } } }
3089 { auto _e = output_tensor_metadata(); if (_e) { _o->output_tensor_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->output_tensor_metadata[_i] = std::unique_ptr<tflite::TensorMetadataT>(_e->Get(_i)->UnPack(_resolver)); } } }
3090 { auto _e = associated_files(); if (_e) { _o->associated_files.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->associated_files[_i] = std::unique_ptr<tflite::AssociatedFileT>(_e->Get(_i)->UnPack(_resolver)); } } }
3091 { auto _e = input_process_units(); if (_e) { _o->input_process_units.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->input_process_units[_i] = std::unique_ptr<tflite::ProcessUnitT>(_e->Get(_i)->UnPack(_resolver)); } } }
3092 { auto _e = output_process_units(); if (_e) { _o->output_process_units.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->output_process_units[_i] = std::unique_ptr<tflite::ProcessUnitT>(_e->Get(_i)->UnPack(_resolver)); } } }
3093 { auto _e = input_tensor_groups(); if (_e) { _o->input_tensor_groups.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->input_tensor_groups[_i] = std::unique_ptr<tflite::TensorGroupT>(_e->Get(_i)->UnPack(_resolver)); } } }
3094 { auto _e = output_tensor_groups(); if (_e) { _o->output_tensor_groups.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->output_tensor_groups[_i] = std::unique_ptr<tflite::TensorGroupT>(_e->Get(_i)->UnPack(_resolver)); } } }
3095 }
3096
3097 inline flatbuffers::Offset<SubGraphMetadata> SubGraphMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
3098 return CreateSubGraphMetadata(_fbb, _o, _rehasher);
3099 }
3100
3101 inline flatbuffers::Offset<SubGraphMetadata> CreateSubGraphMetadata(flatbuffers::FlatBufferBuilder &_fbb, const SubGraphMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
3102 (void)_rehasher;
3103 (void)_o;
3104 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SubGraphMetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
3105 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
3106 auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
3107 auto _input_tensor_metadata = _o->input_tensor_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMetadata>> (_o->input_tensor_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMetadata(*__va->__fbb, __va->__o->input_tensor_metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
3108 auto _output_tensor_metadata = _o->output_tensor_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorMetadata>> (_o->output_tensor_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorMetadata(*__va->__fbb, __va->__o->output_tensor_metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
3109 auto _associated_files = _o->associated_files.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>> (_o->associated_files.size(), [](size_t i, _VectorArgs *__va) { return CreateAssociatedFile(*__va->__fbb, __va->__o->associated_files[i].get(), __va->__rehasher); }, &_va ) : 0;
3110 auto _input_process_units = _o->input_process_units.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::ProcessUnit>> (_o->input_process_units.size(), [](size_t i, _VectorArgs *__va) { return CreateProcessUnit(*__va->__fbb, __va->__o->input_process_units[i].get(), __va->__rehasher); }, &_va ) : 0;
3111 auto _output_process_units = _o->output_process_units.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::ProcessUnit>> (_o->output_process_units.size(), [](size_t i, _VectorArgs *__va) { return CreateProcessUnit(*__va->__fbb, __va->__o->output_process_units[i].get(), __va->__rehasher); }, &_va ) : 0;
3112 auto _input_tensor_groups = _o->input_tensor_groups.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorGroup>> (_o->input_tensor_groups.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorGroup(*__va->__fbb, __va->__o->input_tensor_groups[i].get(), __va->__rehasher); }, &_va ) : 0;
3113 auto _output_tensor_groups = _o->output_tensor_groups.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::TensorGroup>> (_o->output_tensor_groups.size(), [](size_t i, _VectorArgs *__va) { return CreateTensorGroup(*__va->__fbb, __va->__o->output_tensor_groups[i].get(), __va->__rehasher); }, &_va ) : 0;
3114 return tflite::CreateSubGraphMetadata(
3115 _fbb,
3116 _name,
3117 _description,
3118 _input_tensor_metadata,
3119 _output_tensor_metadata,
3120 _associated_files,
3121 _input_process_units,
3122 _output_process_units,
3123 _input_tensor_groups,
3124 _output_tensor_groups);
3125 }
3126
3127 inline ModelMetadataT::ModelMetadataT(const ModelMetadataT &o)
3128 : name(o.name),
3129 description(o.description),
3130 version(o.version),
3131 author(o.author),
3132 license(o.license),
3133 min_parser_version(o.min_parser_version) {
3134 subgraph_metadata.reserve(o.subgraph_metadata.size());
3135 for (const auto &subgraph_metadata_ : o.subgraph_metadata) { subgraph_metadata.emplace_back((subgraph_metadata_) ? new tflite::SubGraphMetadataT(*subgraph_metadata_) : nullptr); }
3136 associated_files.reserve(o.associated_files.size());
3137 for (const auto &associated_files_ : o.associated_files) { associated_files.emplace_back((associated_files_) ? new tflite::AssociatedFileT(*associated_files_) : nullptr); }
3138 }
3139
3140 inline ModelMetadataT &ModelMetadataT::operator=(ModelMetadataT o) FLATBUFFERS_NOEXCEPT {
3141 std::swap(name, o.name);
3142 std::swap(description, o.description);
3143 std::swap(version, o.version);
3144 std::swap(subgraph_metadata, o.subgraph_metadata);
3145 std::swap(author, o.author);
3146 std::swap(license, o.license);
3147 std::swap(associated_files, o.associated_files);
3148 std::swap(min_parser_version, o.min_parser_version);
3149 return *this;
3150 }
3151
3152 inline ModelMetadataT *ModelMetadata::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
3153 auto _o = std::unique_ptr<ModelMetadataT>(new ModelMetadataT());
3154 UnPackTo(_o.get(), _resolver);
3155 return _o.release();
3156 }
3157
3158 inline void ModelMetadata::UnPackTo(ModelMetadataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
3159 (void)_o;
3160 (void)_resolver;
3161 { auto _e = name(); if (_e) _o->name = _e->str(); }
3162 { auto _e = description(); if (_e) _o->description = _e->str(); }
3163 { auto _e = version(); if (_e) _o->version = _e->str(); }
3164 { auto _e = subgraph_metadata(); if (_e) { _o->subgraph_metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->subgraph_metadata[_i] = std::unique_ptr<tflite::SubGraphMetadataT>(_e->Get(_i)->UnPack(_resolver)); } } }
3165 { auto _e = author(); if (_e) _o->author = _e->str(); }
3166 { auto _e = license(); if (_e) _o->license = _e->str(); }
3167 { auto _e = associated_files(); if (_e) { _o->associated_files.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->associated_files[_i] = std::unique_ptr<tflite::AssociatedFileT>(_e->Get(_i)->UnPack(_resolver)); } } }
3168 { auto _e = min_parser_version(); if (_e) _o->min_parser_version = _e->str(); }
3169 }
3170
3171 inline flatbuffers::Offset<ModelMetadata> ModelMetadata::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ModelMetadataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
3172 return CreateModelMetadata(_fbb, _o, _rehasher);
3173 }
3174
3175 inline flatbuffers::Offset<ModelMetadata> CreateModelMetadata(flatbuffers::FlatBufferBuilder &_fbb, const ModelMetadataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
3176 (void)_rehasher;
3177 (void)_o;
3178 struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ModelMetadataT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
3179 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
3180 auto _description = _o->description.empty() ? 0 : _fbb.CreateString(_o->description);
3181 auto _version = _o->version.empty() ? 0 : _fbb.CreateString(_o->version);
3182 auto _subgraph_metadata = _o->subgraph_metadata.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::SubGraphMetadata>> (_o->subgraph_metadata.size(), [](size_t i, _VectorArgs *__va) { return CreateSubGraphMetadata(*__va->__fbb, __va->__o->subgraph_metadata[i].get(), __va->__rehasher); }, &_va ) : 0;
3183 auto _author = _o->author.empty() ? 0 : _fbb.CreateString(_o->author);
3184 auto _license = _o->license.empty() ? 0 : _fbb.CreateString(_o->license);
3185 auto _associated_files = _o->associated_files.size() ? _fbb.CreateVector<flatbuffers::Offset<tflite::AssociatedFile>> (_o->associated_files.size(), [](size_t i, _VectorArgs *__va) { return CreateAssociatedFile(*__va->__fbb, __va->__o->associated_files[i].get(), __va->__rehasher); }, &_va ) : 0;
3186 auto _min_parser_version = _o->min_parser_version.empty() ? 0 : _fbb.CreateString(_o->min_parser_version);
3187 return tflite::CreateModelMetadata(
3188 _fbb,
3189 _name,
3190 _description,
3191 _version,
3192 _subgraph_metadata,
3193 _author,
3194 _license,
3195 _associated_files,
3196 _min_parser_version);
3197 }
3198
3199 inline bool VerifyContentProperties(flatbuffers::Verifier &verifier, const void *obj, ContentProperties type) {
3200 switch (type) {
3201 case ContentProperties_NONE: {
3202 return true;
3203 }
3204 case ContentProperties_FeatureProperties: {
3205 auto ptr = reinterpret_cast<const tflite::FeatureProperties *>(obj);
3206 return verifier.VerifyTable(ptr);
3207 }
3208 case ContentProperties_ImageProperties: {
3209 auto ptr = reinterpret_cast<const tflite::ImageProperties *>(obj);
3210 return verifier.VerifyTable(ptr);
3211 }
3212 case ContentProperties_BoundingBoxProperties: {
3213 auto ptr = reinterpret_cast<const tflite::BoundingBoxProperties *>(obj);
3214 return verifier.VerifyTable(ptr);
3215 }
3216 case ContentProperties_AudioProperties: {
3217 auto ptr = reinterpret_cast<const tflite::AudioProperties *>(obj);
3218 return verifier.VerifyTable(ptr);
3219 }
3220 default: return true;
3221 }
3222 }
3223
3224 inline bool VerifyContentPropertiesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
3225 if (!values || !types) return !values && !types;
3226 if (values->size() != types->size()) return false;
3227 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3228 if (!VerifyContentProperties(
3229 verifier, values->Get(i), types->GetEnum<ContentProperties>(i))) {
3230 return false;
3231 }
3232 }
3233 return true;
3234 }
3235
3236 inline void *ContentPropertiesUnion::UnPack(const void *obj, ContentProperties type, const flatbuffers::resolver_function_t *resolver) {
3237 (void)resolver;
3238 switch (type) {
3239 case ContentProperties_FeatureProperties: {
3240 auto ptr = reinterpret_cast<const tflite::FeatureProperties *>(obj);
3241 return ptr->UnPack(resolver);
3242 }
3243 case ContentProperties_ImageProperties: {
3244 auto ptr = reinterpret_cast<const tflite::ImageProperties *>(obj);
3245 return ptr->UnPack(resolver);
3246 }
3247 case ContentProperties_BoundingBoxProperties: {
3248 auto ptr = reinterpret_cast<const tflite::BoundingBoxProperties *>(obj);
3249 return ptr->UnPack(resolver);
3250 }
3251 case ContentProperties_AudioProperties: {
3252 auto ptr = reinterpret_cast<const tflite::AudioProperties *>(obj);
3253 return ptr->UnPack(resolver);
3254 }
3255 default: return nullptr;
3256 }
3257 }
3258
3259 inline flatbuffers::Offset<void> ContentPropertiesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
3260 (void)_rehasher;
3261 switch (type) {
3262 case ContentProperties_FeatureProperties: {
3263 auto ptr = reinterpret_cast<const tflite::FeaturePropertiesT *>(value);
3264 return CreateFeatureProperties(_fbb, ptr, _rehasher).Union();
3265 }
3266 case ContentProperties_ImageProperties: {
3267 auto ptr = reinterpret_cast<const tflite::ImagePropertiesT *>(value);
3268 return CreateImageProperties(_fbb, ptr, _rehasher).Union();
3269 }
3270 case ContentProperties_BoundingBoxProperties: {
3271 auto ptr = reinterpret_cast<const tflite::BoundingBoxPropertiesT *>(value);
3272 return CreateBoundingBoxProperties(_fbb, ptr, _rehasher).Union();
3273 }
3274 case ContentProperties_AudioProperties: {
3275 auto ptr = reinterpret_cast<const tflite::AudioPropertiesT *>(value);
3276 return CreateAudioProperties(_fbb, ptr, _rehasher).Union();
3277 }
3278 default: return 0;
3279 }
3280 }
3281
3282 inline ContentPropertiesUnion::ContentPropertiesUnion(const ContentPropertiesUnion &u) : type(u.type), value(nullptr) {
3283 switch (type) {
3284 case ContentProperties_FeatureProperties: {
3285 value = new tflite::FeaturePropertiesT(*reinterpret_cast<tflite::FeaturePropertiesT *>(u.value));
3286 break;
3287 }
3288 case ContentProperties_ImageProperties: {
3289 value = new tflite::ImagePropertiesT(*reinterpret_cast<tflite::ImagePropertiesT *>(u.value));
3290 break;
3291 }
3292 case ContentProperties_BoundingBoxProperties: {
3293 value = new tflite::BoundingBoxPropertiesT(*reinterpret_cast<tflite::BoundingBoxPropertiesT *>(u.value));
3294 break;
3295 }
3296 case ContentProperties_AudioProperties: {
3297 value = new tflite::AudioPropertiesT(*reinterpret_cast<tflite::AudioPropertiesT *>(u.value));
3298 break;
3299 }
3300 default:
3301 break;
3302 }
3303 }
3304
3305 inline void ContentPropertiesUnion::Reset() {
3306 switch (type) {
3307 case ContentProperties_FeatureProperties: {
3308 auto ptr = reinterpret_cast<tflite::FeaturePropertiesT *>(value);
3309 delete ptr;
3310 break;
3311 }
3312 case ContentProperties_ImageProperties: {
3313 auto ptr = reinterpret_cast<tflite::ImagePropertiesT *>(value);
3314 delete ptr;
3315 break;
3316 }
3317 case ContentProperties_BoundingBoxProperties: {
3318 auto ptr = reinterpret_cast<tflite::BoundingBoxPropertiesT *>(value);
3319 delete ptr;
3320 break;
3321 }
3322 case ContentProperties_AudioProperties: {
3323 auto ptr = reinterpret_cast<tflite::AudioPropertiesT *>(value);
3324 delete ptr;
3325 break;
3326 }
3327 default: break;
3328 }
3329 value = nullptr;
3330 type = ContentProperties_NONE;
3331 }
3332
3333 inline bool VerifyProcessUnitOptions(flatbuffers::Verifier &verifier, const void *obj, ProcessUnitOptions type) {
3334 switch (type) {
3335 case ProcessUnitOptions_NONE: {
3336 return true;
3337 }
3338 case ProcessUnitOptions_NormalizationOptions: {
3339 auto ptr = reinterpret_cast<const tflite::NormalizationOptions *>(obj);
3340 return verifier.VerifyTable(ptr);
3341 }
3342 case ProcessUnitOptions_ScoreCalibrationOptions: {
3343 auto ptr = reinterpret_cast<const tflite::ScoreCalibrationOptions *>(obj);
3344 return verifier.VerifyTable(ptr);
3345 }
3346 case ProcessUnitOptions_ScoreThresholdingOptions: {
3347 auto ptr = reinterpret_cast<const tflite::ScoreThresholdingOptions *>(obj);
3348 return verifier.VerifyTable(ptr);
3349 }
3350 case ProcessUnitOptions_BertTokenizerOptions: {
3351 auto ptr = reinterpret_cast<const tflite::BertTokenizerOptions *>(obj);
3352 return verifier.VerifyTable(ptr);
3353 }
3354 case ProcessUnitOptions_SentencePieceTokenizerOptions: {
3355 auto ptr = reinterpret_cast<const tflite::SentencePieceTokenizerOptions *>(obj);
3356 return verifier.VerifyTable(ptr);
3357 }
3358 case ProcessUnitOptions_RegexTokenizerOptions: {
3359 auto ptr = reinterpret_cast<const tflite::RegexTokenizerOptions *>(obj);
3360 return verifier.VerifyTable(ptr);
3361 }
3362 default: return true;
3363 }
3364 }
3365
3366 inline bool VerifyProcessUnitOptionsVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
3367 if (!values || !types) return !values && !types;
3368 if (values->size() != types->size()) return false;
3369 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
3370 if (!VerifyProcessUnitOptions(
3371 verifier, values->Get(i), types->GetEnum<ProcessUnitOptions>(i))) {
3372 return false;
3373 }
3374 }
3375 return true;
3376 }
3377
3378 inline void *ProcessUnitOptionsUnion::UnPack(const void *obj, ProcessUnitOptions type, const flatbuffers::resolver_function_t *resolver) {
3379 (void)resolver;
3380 switch (type) {
3381 case ProcessUnitOptions_NormalizationOptions: {
3382 auto ptr = reinterpret_cast<const tflite::NormalizationOptions *>(obj);
3383 return ptr->UnPack(resolver);
3384 }
3385 case ProcessUnitOptions_ScoreCalibrationOptions: {
3386 auto ptr = reinterpret_cast<const tflite::ScoreCalibrationOptions *>(obj);
3387 return ptr->UnPack(resolver);
3388 }
3389 case ProcessUnitOptions_ScoreThresholdingOptions: {
3390 auto ptr = reinterpret_cast<const tflite::ScoreThresholdingOptions *>(obj);
3391 return ptr->UnPack(resolver);
3392 }
3393 case ProcessUnitOptions_BertTokenizerOptions: {
3394 auto ptr = reinterpret_cast<const tflite::BertTokenizerOptions *>(obj);
3395 return ptr->UnPack(resolver);
3396 }
3397 case ProcessUnitOptions_SentencePieceTokenizerOptions: {
3398 auto ptr = reinterpret_cast<const tflite::SentencePieceTokenizerOptions *>(obj);
3399 return ptr->UnPack(resolver);
3400 }
3401 case ProcessUnitOptions_RegexTokenizerOptions: {
3402 auto ptr = reinterpret_cast<const tflite::RegexTokenizerOptions *>(obj);
3403 return ptr->UnPack(resolver);
3404 }
3405 default: return nullptr;
3406 }
3407 }
3408
3409 inline flatbuffers::Offset<void> ProcessUnitOptionsUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
3410 (void)_rehasher;
3411 switch (type) {
3412 case ProcessUnitOptions_NormalizationOptions: {
3413 auto ptr = reinterpret_cast<const tflite::NormalizationOptionsT *>(value);
3414 return CreateNormalizationOptions(_fbb, ptr, _rehasher).Union();
3415 }
3416 case ProcessUnitOptions_ScoreCalibrationOptions: {
3417 auto ptr = reinterpret_cast<const tflite::ScoreCalibrationOptionsT *>(value);
3418 return CreateScoreCalibrationOptions(_fbb, ptr, _rehasher).Union();
3419 }
3420 case ProcessUnitOptions_ScoreThresholdingOptions: {
3421 auto ptr = reinterpret_cast<const tflite::ScoreThresholdingOptionsT *>(value);
3422 return CreateScoreThresholdingOptions(_fbb, ptr, _rehasher).Union();
3423 }
3424 case ProcessUnitOptions_BertTokenizerOptions: {
3425 auto ptr = reinterpret_cast<const tflite::BertTokenizerOptionsT *>(value);
3426 return CreateBertTokenizerOptions(_fbb, ptr, _rehasher).Union();
3427 }
3428 case ProcessUnitOptions_SentencePieceTokenizerOptions: {
3429 auto ptr = reinterpret_cast<const tflite::SentencePieceTokenizerOptionsT *>(value);
3430 return CreateSentencePieceTokenizerOptions(_fbb, ptr, _rehasher).Union();
3431 }
3432 case ProcessUnitOptions_RegexTokenizerOptions: {
3433 auto ptr = reinterpret_cast<const tflite::RegexTokenizerOptionsT *>(value);
3434 return CreateRegexTokenizerOptions(_fbb, ptr, _rehasher).Union();
3435 }
3436 default: return 0;
3437 }
3438 }
3439
3440 inline ProcessUnitOptionsUnion::ProcessUnitOptionsUnion(const ProcessUnitOptionsUnion &u) : type(u.type), value(nullptr) {
3441 switch (type) {
3442 case ProcessUnitOptions_NormalizationOptions: {
3443 value = new tflite::NormalizationOptionsT(*reinterpret_cast<tflite::NormalizationOptionsT *>(u.value));
3444 break;
3445 }
3446 case ProcessUnitOptions_ScoreCalibrationOptions: {
3447 value = new tflite::ScoreCalibrationOptionsT(*reinterpret_cast<tflite::ScoreCalibrationOptionsT *>(u.value));
3448 break;
3449 }
3450 case ProcessUnitOptions_ScoreThresholdingOptions: {
3451 value = new tflite::ScoreThresholdingOptionsT(*reinterpret_cast<tflite::ScoreThresholdingOptionsT *>(u.value));
3452 break;
3453 }
3454 case ProcessUnitOptions_BertTokenizerOptions: {
3455 value = new tflite::BertTokenizerOptionsT(*reinterpret_cast<tflite::BertTokenizerOptionsT *>(u.value));
3456 break;
3457 }
3458 case ProcessUnitOptions_SentencePieceTokenizerOptions: {
3459 value = new tflite::SentencePieceTokenizerOptionsT(*reinterpret_cast<tflite::SentencePieceTokenizerOptionsT *>(u.value));
3460 break;
3461 }
3462 case ProcessUnitOptions_RegexTokenizerOptions: {
3463 value = new tflite::RegexTokenizerOptionsT(*reinterpret_cast<tflite::RegexTokenizerOptionsT *>(u.value));
3464 break;
3465 }
3466 default:
3467 break;
3468 }
3469 }
3470
3471 inline void ProcessUnitOptionsUnion::Reset() {
3472 switch (type) {
3473 case ProcessUnitOptions_NormalizationOptions: {
3474 auto ptr = reinterpret_cast<tflite::NormalizationOptionsT *>(value);
3475 delete ptr;
3476 break;
3477 }
3478 case ProcessUnitOptions_ScoreCalibrationOptions: {
3479 auto ptr = reinterpret_cast<tflite::ScoreCalibrationOptionsT *>(value);
3480 delete ptr;
3481 break;
3482 }
3483 case ProcessUnitOptions_ScoreThresholdingOptions: {
3484 auto ptr = reinterpret_cast<tflite::ScoreThresholdingOptionsT *>(value);
3485 delete ptr;
3486 break;
3487 }
3488 case ProcessUnitOptions_BertTokenizerOptions: {
3489 auto ptr = reinterpret_cast<tflite::BertTokenizerOptionsT *>(value);
3490 delete ptr;
3491 break;
3492 }
3493 case ProcessUnitOptions_SentencePieceTokenizerOptions: {
3494 auto ptr = reinterpret_cast<tflite::SentencePieceTokenizerOptionsT *>(value);
3495 delete ptr;
3496 break;
3497 }
3498 case ProcessUnitOptions_RegexTokenizerOptions: {
3499 auto ptr = reinterpret_cast<tflite::RegexTokenizerOptionsT *>(value);
3500 delete ptr;
3501 break;
3502 }
3503 default: break;
3504 }
3505 value = nullptr;
3506 type = ProcessUnitOptions_NONE;
3507 }
3508
3509 inline const tflite::ModelMetadata *GetModelMetadata(const void *buf) {
3510 return flatbuffers::GetRoot<tflite::ModelMetadata>(buf);
3511 }
3512
3513 inline const tflite::ModelMetadata *GetSizePrefixedModelMetadata(const void *buf) {
3514 return flatbuffers::GetSizePrefixedRoot<tflite::ModelMetadata>(buf);
3515 }
3516
3517 inline const char *ModelMetadataIdentifier() {
3518 return "M001";
3519 }
3520
3521 inline bool ModelMetadataBufferHasIdentifier(const void *buf) {
3522 return flatbuffers::BufferHasIdentifier(
3523 buf, ModelMetadataIdentifier());
3524 }
3525
3526 inline bool SizePrefixedModelMetadataBufferHasIdentifier(const void *buf) {
3527 return flatbuffers::BufferHasIdentifier(
3528 buf, ModelMetadataIdentifier(), true);
3529 }
3530
3531 inline bool VerifyModelMetadataBuffer(
3532 flatbuffers::Verifier &verifier) {
3533 return verifier.VerifyBuffer<tflite::ModelMetadata>(ModelMetadataIdentifier());
3534 }
3535
3536 inline bool VerifySizePrefixedModelMetadataBuffer(
3537 flatbuffers::Verifier &verifier) {
3538 return verifier.VerifySizePrefixedBuffer<tflite::ModelMetadata>(ModelMetadataIdentifier());
3539 }
3540
3541 inline const char *ModelMetadataExtension() {
3542 return "tflitemeta";
3543 }
3544
3545 inline void FinishModelMetadataBuffer(
3546 flatbuffers::FlatBufferBuilder &fbb,
3547 flatbuffers::Offset<tflite::ModelMetadata> root) {
3548 fbb.Finish(root, ModelMetadataIdentifier());
3549 }
3550
3551 inline void FinishSizePrefixedModelMetadataBuffer(
3552 flatbuffers::FlatBufferBuilder &fbb,
3553 flatbuffers::Offset<tflite::ModelMetadata> root) {
3554 fbb.FinishSizePrefixed(root, ModelMetadataIdentifier());
3555 }
3556
3557 inline std::unique_ptr<tflite::ModelMetadataT> UnPackModelMetadata(
3558 const void *buf,
3559 const flatbuffers::resolver_function_t *res = nullptr) {
3560 return std::unique_ptr<tflite::ModelMetadataT>(GetModelMetadata(buf)->UnPack(res));
3561 }
3562
3563 inline std::unique_ptr<tflite::ModelMetadataT> UnPackSizePrefixedModelMetadata(
3564 const void *buf,
3565 const flatbuffers::resolver_function_t *res = nullptr) {
3566 return std::unique_ptr<tflite::ModelMetadataT>(GetSizePrefixedModelMetadata(buf)->UnPack(res));
3567 }
3568
3569 } // namespace tflite
3570
3571 #endif // FLATBUFFERS_GENERATED_METADATASCHEMA_TFLITE_H_
3572